Install Grafana on Grafana Labs

Install Grafana on Debian or Ubuntu

Fri, 03 Apr 2026 19:43:06 +0000

Install Grafana on Debian or Ubuntu

This topic explains how to install Grafana dependencies, install Grafana on Linux Debian or Ubuntu, and start the Grafana server on your Debian or Ubuntu system.

There are multiple ways to install Grafana: using the Grafana Labs APT repository, by downloading a .deb package, or by downloading a binary .tar.gz file. Choose only one of the methods below that best suits your needs.

Note
If you install via the .deb package or .tar.gz file, then you must manually update Grafana for each new version.

The following video demonstrates how to install Grafana on Debian and Ubuntu as outlined in this document:

Install from APT repository

If you install from the APT repository, Grafana automatically updates when you run apt-get update.

Grafana Version	Package	Repository
Grafana Enterprise	grafana-enterprise	`https://apt.grafana.com stable main`
Grafana Enterprise (Beta)	grafana-enterprise	`https://apt.grafana.com beta main`
Grafana OSS	grafana	`https://apt.grafana.com stable main`
Grafana OSS (Beta)	grafana	`https://apt.grafana.com beta main`

Note
Grafana Enterprise is the recommended and default edition. It is available for free and includes all the features of the OSS edition. You can also upgrade to the full Enterprise feature set, which has support for Enterprise plugins.

Complete the following steps to install Grafana from the APT repository:

Install the prerequisite packages:

sudo apt-get install -y apt-transport-https wget gnupg

Import the GPG key:

sudo mkdir -p /etc/apt/keyrings
sudo wget -O /etc/apt/keyrings/grafana.asc https://apt.grafana.com/gpg-full.key
sudo chmod 644 /etc/apt/keyrings/grafana.asc

To add a repository for stable releases, run the following command:

echo "deb [signed-by=/etc/apt/keyrings/grafana.asc] https://apt.grafana.com stable main" | sudo tee -a /etc/apt/sources.list.d/grafana.list

To add a repository for beta releases, run the following command:

echo "deb [signed-by=/etc/apt/keyrings/grafana.asc] https://apt.grafana.com beta main" | sudo tee -a /etc/apt/sources.list.d/grafana.list

Run the following command to update the list of available packages:
Bash
```
# Updates the list of available packages
sudo apt-get update
```

To install Grafana OSS, run the following command:

# Installs the latest OSS release:
sudo apt-get install grafana

To install Grafana Enterprise, run the following command:

# Installs the latest Enterprise release:
sudo apt-get install grafana-enterprise

Install Grafana using a deb package

If you install Grafana manually using the deb package, then you must manually update Grafana for each new version.

Complete the following steps to install Grafana using a deb package:

Navigate to the Grafana download page.
Select the Grafana version you want to install.
- The most recent Grafana version is selected by default.
- The Version field displays only tagged releases. If you want to install a nightly build, click Nightly Builds and then select a version.
Select an Edition.
- Enterprise: This is the recommended version. It is functionally identical to the open source version, but includes features you can unlock with a license, if you so choose.
- Open Source: This version is functionally identical to the Enterprise version, but you will need to download the Enterprise version if you want Enterprise features.
Depending on which system you are running, click the Linux or ARM tab on the download page.
Copy and paste the code from the download page into your command line and run.

Install Grafana as a standalone binary

Complete the following steps to install Grafana using the standalone binaries:

Navigate to the Grafana download page.
Select the Grafana version you want to install.
- The most recent Grafana version is selected by default.
- The Version field displays only tagged releases. If you want to install a nightly build, click Nightly Builds and then select a version.
Select an Edition.
- Enterprise: This is the recommended version. It is functionally identical to the open source version but includes features you can unlock with a license if you so choose.
- Open Source: This version is functionally identical to the Enterprise version, but you will need to download the Enterprise version if you want Enterprise features.
Depending on which system you are running, click the Linux or ARM tab on the download page.
Copy and paste the code from the download page page into your command line and run.
Create a user account for Grafana on your system:
shell
```
sudo useradd -r -s /bin/false grafana
```
Move the unpacked binary to /usr/local/grafana:
shell
```
sudo mv <DOWNLOAD PATH> /usr/local/grafana
```
Change the owner of /usr/local/grafana to Grafana users:
shell
```
sudo chown -R grafana:users /usr/local/grafana
```

Create a Grafana server systemd unit file:

sudo touch /etc/systemd/system/grafana-server.service

Add the following to the unit file in a text editor of your choice:

[Unit]
Description=Grafana Server
After=network.target

[Service]
Type=simple
User=grafana
Group=users
ExecStart=/usr/local/grafana/bin/grafana server --config=/usr/local/grafana/conf/grafana.ini --homepath=/usr/local/grafana
Restart=on-failure

[Install]
WantedBy=multi-user.target

Use the binary to manually start the Grafana server:
shell
```
/usr/local/grafana/bin/grafana server --homepath /usr/local/grafana
```
Note
Manually invoking the binary in this step automatically creates the /usr/local/grafana/data directory, which needs to be created and configured before the installation can be considered complete.
Press CTRL+C to stop the Grafana server.
Change the owner of /usr/local/grafana to Grafana users again to apply the ownership to the newly created /usr/local/grafana/data directory:
shell
```
sudo chown -R grafana:users /usr/local/grafana
```
Configure the Grafana server to start at boot time using systemd.

Uninstall on Debian or Ubuntu

Complete any of the following steps to uninstall Grafana.

To uninstall Grafana, run the following commands in a terminal window:

If you configured Grafana to run with systemd, stop the systemd service for Grafana server:
shell
```
sudo systemctl stop grafana-server
```
If you configured Grafana to run with init.d, stop the init.d service for Grafana server:
shell
```
sudo service grafana-server stop
```
To uninstall Grafana OSS:
shell
```
sudo apt-get remove grafana
```
To uninstall Grafana Enterprise:
shell
```
sudo apt-get remove grafana-enterprise
```
Optional: To remove the Grafana repository:
Bash
```
sudo rm -i /etc/apt/sources.list.d/grafana.list
```

Next steps

Start the Grafana server

Install Grafana on RHEL or Fedora

Fri, 03 Apr 2026 19:43:06 +0000

Install Grafana on RHEL or Fedora

This topic explains how to install Grafana dependencies, install Grafana on RHEL or Fedora, and start the Grafana server on your system.

You can install Grafana from the RPM repository, from standalone RPM, or with the binary .tar.gz file.

If you install via RPM or the .tar.gz file, then you must manually update Grafana for each new version.

The following video demonstrates how to install Grafana on RHEL or Fedora as outlined in this document:

Install Grafana from the RPM repository

If you install from the RPM repository, then Grafana is automatically updated every time you update your applications.

Grafana Version	Package	Repository
Grafana Enterprise	grafana-enterprise	`https://rpm.grafana.com`
Grafana Enterprise (Beta)	grafana-enterprise	`https://rpm-beta.grafana.com`
Grafana OSS	grafana	`https://rpm.grafana.com`
Grafana OSS (Beta)	grafana	`https://rpm-beta.grafana.com`

Note
Grafana Enterprise is the recommended and default edition. It is available for free and includes all the features of the OSS edition. You can also upgrade to the full Enterprise feature set, which has support for Enterprise plugins.

To install Grafana from the RPM repository, complete the following steps:

Note
If you wish to install beta versions of Grafana, substitute the repository URL for the beta URL listed above.

Import the GPG key:

wget -q -O gpg.key https://rpm.grafana.com/gpg.key
sudo rpm --import gpg.key

Create /etc/yum.repos.d/grafana.repo with the following content:

[grafana]
name=grafana
baseurl=https://rpm.grafana.com
repo_gpgcheck=1
enabled=1
gpgcheck=1
gpgkey=https://rpm.grafana.com/gpg.key
sslverify=1
sslcacert=/etc/pki/tls/certs/ca-bundle.crt

To install Grafana OSS, run the following command:
Bash
```
sudo dnf install grafana
```
To install Grafana Enterprise, run the following command:
Bash
```
sudo dnf install grafana-enterprise
```

Install the Grafana RPM package manually

If you install Grafana manually using YUM or RPM, then you must manually update Grafana for each new version. This method varies according to which Linux OS you are running.

Note: The RPM files are signed. You can verify the signature with this public GPG key.

On the Grafana download page, select the Grafana version you want to install.
- The most recent Grafana version is selected by default.
- The Version field displays only finished releases. If you want to install a beta version, click Nightly Builds and then select a version.
Select an Edition.
- Enterprise - Recommended download. Functionally identical to the open source version, but includes features you can unlock with a license if you so choose.
- Open Source - Functionally identical to the Enterprise version, but you will need to download the Enterprise version if you want Enterprise features.
Depending on which system you are running, click Linux or ARM.
Copy and paste the RPM package URL and the local RPM package information from the download page into the pattern shown below and run the command.
Bash
```
sudo yum install -y <rpm package url>
```

Install Grafana as a standalone binary

If you install Grafana manually using the standalone binaries, then you must manually update Grafana for each new version.

Complete the following steps to install Grafana using the standalone binaries:

Navigate to the Grafana download page.
Select the Grafana version you want to install.
- The most recent Grafana version is selected by default.
- The Version field displays only tagged releases. If you want to install a nightly build, click Nightly Builds and then select a version.
Select an Edition.
- Enterprise: This is the recommended version. It is functionally identical to the open source version but includes features you can unlock with a license if you so choose.
- Open Source: This version is functionally identical to the Enterprise version, but you will need to download the Enterprise version if you want Enterprise features.
Depending on which system you are running, click the Linux or ARM tab on the download page.
Copy and paste the code from the download page page into your command line and run.
Create a user account for Grafana on your system:
shell
```
sudo useradd -r -s /bin/false grafana
```
Move the unpacked binary to /usr/local/grafana:
shell
```
sudo mv <DOWNLOAD PATH> /usr/local/grafana
```
Change the owner of /usr/local/grafana to Grafana users:
shell
```
sudo chown -R grafana:users /usr/local/grafana
```

Create a Grafana server systemd unit file:

sudo touch /etc/systemd/system/grafana-server.service

Add the following to the unit file in a text editor of your choice:

[Unit]
Description=Grafana Server
After=network.target

[Service]
Type=simple
User=grafana
Group=users
ExecStart=/usr/local/grafana/bin/grafana server --config=/usr/local/grafana/conf/grafana.ini --homepath=/usr/local/grafana
Restart=on-failure

[Install]
WantedBy=multi-user.target

Use the binary to manually start the Grafana server:
shell
```
/usr/local/grafana/bin/grafana-server --homepath /usr/local/grafana
```
Note
Manually invoking the binary in this step automatically creates the /usr/local/grafana/data directory, which needs to be created and configured before the installation can be considered complete.
Press CTRL+C to stop the Grafana server.
Change the owner of /usr/local/grafana to Grafana users again to apply the ownership to the newly created /usr/local/grafana/data directory:
shell
```
sudo chown -R grafana:users /usr/local/grafana
```
Configure the Grafana server to start at boot time using systemd.

Uninstall on RHEL or Fedora

To uninstall Grafana, run the following commands in a terminal window:

If you configured Grafana to run with systemd, stop the systemd service for Grafana server:
shell
```
sudo systemctl stop grafana-server
```
If you configured Grafana to run with init.d, stop the init.d service for Grafana server:
shell
```
sudo service grafana-server stop
```
To uninstall Grafana OSS:
shell
```
sudo dnf remove grafana
```
To uninstall Grafana Enterprise:
shell
```
sudo dnf remove grafana-enterprise
```
Optional: To remove the Grafana repository:
shell
```
sudo rm -i /etc/yum.repos.d/grafana.repo
```

Next steps

Refer to Start the Grafana server.

Install Grafana on SUSE or openSUSE

Fri, 03 Apr 2026 19:43:06 +0000

Install Grafana on SUSE or openSUSE

This topic explains how to install Grafana dependencies, install Grafana on SUSE or openSUSE and start the Grafana server on your system.

You can install Grafana using the RPM repository, or by downloading a binary .tar.gz file.

If you install via RPM or the .tar.gz file, then you must manually update Grafana for each new version.

The following video demonstrates how to install Grafana on SUSE or openSUSE as outlined in this document:

Install Grafana from the RPM repository

If you install from the RPM repository, then Grafana is automatically updated every time you run sudo zypper update.

Grafana Version	Package	Repository
Grafana Enterprise	grafana-enterprise	`https://rpm.grafana.com`
Grafana OSS	grafana	`https://rpm.grafana.com`

Note
Grafana Enterprise is the recommended and default edition. It is available for free and includes all the features of the OSS edition. You can also upgrade to the full Enterprise feature set, which has support for Enterprise plugins.

To install Grafana using the RPM repository, complete the following steps:

Import the GPG key:

wget -q -O gpg.key https://rpm.grafana.com/gpg.key
sudo rpm --import gpg.key

Use zypper to add the grafana repo.

sudo zypper addrepo https://rpm.grafana.com grafana

To install Grafana OSS, run the following command:
Bash
```
sudo zypper install grafana
```
To install Grafana Enterprise, run the following command:
Bash
```
sudo zypper install grafana-enterprise
```

Install the Grafana RPM package manually

If you install Grafana manually using RPM, then you must manually update Grafana for each new version. This method varies according to which Linux OS you are running.

Note: The RPM files are signed. You can verify the signature with this public GPG key.

On the Grafana download page, select the Grafana version you want to install.
- The most recent Grafana version is selected by default.
- The Version field displays only finished releases. If you want to install a beta version, click Nightly Builds and then select a version.
Select an Edition.
- Enterprise - Recommended download. Functionally identical to the open source version, but includes features you can unlock with a license if you so choose.
- Open Source - Functionally identical to the Enterprise version, but you will need to download the Enterprise version if you want Enterprise features.
Depending on which system you are running, click Linux or ARM.
Copy and paste the RPM package URL and the local RPM package information from the installation page into the pattern shown below, then run the commands.
Bash
```
sudo zypper install initscripts urw-fonts wget
wget <rpm package url>
sudo rpm -Uvh <local rpm package>
```

Install Grafana as a standalone binary

If you install Grafana manually using the standalone binaries, then you must manually update Grafana for each new version.

Complete the following steps to install Grafana using the standalone binaries:

Navigate to the Grafana download page.
Select the Grafana version you want to install.
- The most recent Grafana version is selected by default.
- The Version field displays only tagged releases. If you want to install a nightly build, click Nightly Builds and then select a version.
Select an Edition.
- Enterprise: This is the recommended version. It is functionally identical to the open source version but includes features you can unlock with a license if you so choose.
- Open Source: This version is functionally identical to the Enterprise version, but you will need to download the Enterprise version if you want Enterprise features.
Depending on which system you are running, click the Linux or ARM tab on the download page.
Copy and paste the code from the download page into your command line and run.
Create a user account for Grafana on your system:
shell
```
sudo useradd -r -s /bin/false grafana
```
Move the unpacked binary to /usr/local/grafana:
shell
```
sudo mv <DOWNLOAD PATH> /usr/local/grafana
```
Change the owner of /usr/local/grafana to Grafana users:
shell
```
sudo chown -R grafana:users /usr/local/grafana
```

Create a Grafana server systemd unit file:

sudo touch /etc/systemd/system/grafana-server.service

Add the following to the unit file in a text editor of your choice:

[Unit]
Description=Grafana Server
After=network.target

[Service]
Type=simple
User=grafana
Group=users
ExecStart=/usr/local/grafana/bin/grafana server --config=/usr/local/grafana/conf/grafana.ini --homepath=/usr/local/grafana
Restart=on-failure

[Install]
WantedBy=multi-user.target

Use the binary to manually start the Grafana server:
shell
```
/usr/local/grafana/bin/grafana-server --homepath /usr/local/grafana
```
Note
Manually invoking the binary in this step automatically creates the /usr/local/grafana/data directory, which needs to be created and configured before the installation can be considered complete.
Press CTRL+C to stop the Grafana server.
Change the owner of /usr/local/grafana to Grafana users again to apply the ownership to the newly created /usr/local/grafana/data directory:
shell
```
sudo chown -R grafana:users /usr/local/grafana
```
Configure the Grafana server to start at boot time using systemd.

Uninstall on SUSE or openSUSE

To uninstall Grafana, run the following commands in a terminal window:

If you configured Grafana to run with systemd, stop the systemd service for Grafana server:
shell
```
sudo systemctl stop grafana-server
```
If you configured Grafana to run with init.d, stop the init.d service for Grafana server:
shell
```
sudo service grafana-server stop
```
To uninstall Grafana OSS:
shell
```
sudo zypper remove grafana
```
To uninstall Grafana Enterprise:
shell
```
sudo zypper remove grafana-enterprise
```
Optional: To remove the Grafana repository:
shell
```
sudo zypper removerepo grafana
```

Next steps

Refer to Start the Grafana server.

Run Grafana Docker image

Fri, 03 Apr 2026 19:43:06 +0000

Caution
Starting with Grafana release 12.4.0 , the grafana/grafana-oss Docker Hub repository will no longer be updated. Instead, we encourage you to use the grafana/grafana Docker Hub repository. These two repositories have the same Grafana OSS docker images.

Run Grafana Docker image

This topic guides you through installing Grafana via the official Docker images. Specifically, it covers running Grafana via the Docker command line interface (CLI) and docker-compose.

Grafana Docker images come in two editions:

Grafana Enterprise: grafana/grafana-enterprise
Grafana Open Source: grafana/grafana

Note: The recommended and default edition of Grafana is Grafana Enterprise. It is free and includes all the features of the OSS edition. Additionally, you have the option to upgrade to the full Enterprise feature set, which includes support for Enterprise plugins.

The default images for Grafana are created using the Alpine Linux project and can be found in the Alpine official image. For instructions on configuring a Docker image for Grafana, refer to Configure a Grafana Docker image.

Run Grafana via Docker CLI

This section shows you how to run Grafana using the Docker CLI.

Note: If you are on a Linux system (for example, Debian or Ubuntu), you might need to add sudo before the command or add your user to the docker group. For more information, refer to Linux post-installation steps for Docker Engine.

To run the latest stable version of Grafana, run the following command:

docker run -d -p 3000:3000 --name=grafana grafana/grafana-enterprise

Where:

docker run is a Docker CLI command that runs a new container from an image
-d (--detach) runs the container in the background
-p <host-port>:<container-port> (--publish) publish a container’s port(s) to the host, allowing you to reach the container’s port via a host port. In this case, we can reach the container’s port 3000 via the host’s port 3000
--name assign a logical name to the container (e.g. grafana). This allows you to refer to the container by name instead of by ID.
grafana/grafana-enterprise is the image to run

Stop the Grafana container

To stop the Grafana container, run the following command:

# The `docker ps` command shows the processes running in Docker
docker ps

# This will display a list of containers that looks like the following:
CONTAINER ID   IMAGE  COMMAND   CREATED  STATUS   PORTS    NAMES
cd48d3994968   grafana/grafana-enterprise   "/run.sh"   8 seconds ago   Up 7 seconds   0.0.0.0:3000->3000/tcp   grafana

# To stop the grafana container run the command
# docker stop CONTAINER-ID or use
# docker stop NAME, which is `grafana` as previously defined
docker stop grafana

Save your Grafana data

By default, Grafana uses an embedded SQLite version 3 database to store configuration, users, dashboards, and other data. When you run Docker images as containers, changes to these Grafana data are written to the filesystem within the container, which will only persist for as long as the container exists. If you stop and remove the container, any filesystem changes (i.e. the Grafana data) will be discarded. To avoid losing your data, you can set up persistent storage using Docker volumes or bind mounts for your container.

Note: Though both methods are similar, there is a slight difference. If you want your storage to be fully managed by Docker and accessed only through Docker containers and the Docker CLI, you should choose to use persistent storage. However, if you need full control of the storage and want to allow other processes besides Docker to access or modify the storage layer, then bind mounts is the right choice for your environment.

Use Docker volumes (recommended)

Use Docker volumes when you want the Docker Engine to manage the storage volume.

To use Docker volumes for persistent storage, complete the following steps:

Create a Docker volume to be used by the Grafana container, giving it a descriptive name (e.g. grafana-storage). Run the following command:

# create a persistent volume for your data
docker volume create grafana-storage

# verify that the volume was created correctly
# you should see some JSON output
docker volume inspect grafana-storage

Start the Grafana container by running the following command:

# start grafana
docker run -d -p 3000:3000 --name=grafana \
  --volume grafana-storage:/var/lib/grafana \
  grafana/grafana-enterprise

Use bind mounts

If you plan to use directories on your host for the database or configuration when running Grafana in Docker, you must start the container with a user with permission to access and write to the directory you map.

To use bind mounts, run the following command:

# create a directory for your data
mkdir data

# start grafana with your user id and using the data directory
docker run -d -p 3000:3000 --name=grafana \
  --user "$(id -u)" \
  --volume "$PWD/data:/var/lib/grafana" \
  grafana/grafana-enterprise

Use environment variables to configure Grafana

Grafana supports specifying custom configuration settings using environment variables.

# enable debug logs

docker run -d -p 3000:3000 --name=grafana \
  -e "GF_LOG_LEVEL=debug" \
  grafana/grafana-enterprise

Install plugins in the Docker container

You can install plugins in Grafana from the official and community plugins page or by using a custom URL to install a private plugin. These plugins allow you to add new visualization types, data sources, and applications to help you better visualize your data.

Grafana currently supports three types of plugins: panel, data source, and app. For more information on managing plugins, refer to Plugin Management.

To install plugins in the Docker container, complete the following steps:

Pass the plugins you want to be installed to Docker with the GF_PLUGINS_PREINSTALL environment variable as a comma-separated list.

This starts a background process that installs the list of plugins while Grafana server starts.

For example:
Bash
```
docker run -d -p 3000:3000 --name=grafana \
  -e "GF_PLUGINS_PREINSTALL=grafana-clock-panel, grafana-simple-json-datasource" \
  grafana/grafana-enterprise
```
To specify the version of a plugin, add the version number to the GF_PLUGINS_PREINSTALL environment variable.

For example:
Bash
```
docker run -d -p 3000:3000 --name=grafana \
  -e "GF_PLUGINS_PREINSTALL=grafana-clock-panel@1.0.1" \
  grafana/grafana-enterprise
```
Note: If you do not specify a version number, the latest version is used.

To install a plugin from a custom URL, use the following convention to specify the URL: <plugin ID>@[<plugin version>]@<url to plugin zip>.

For example:

docker run -d -p 3000:3000 --name=grafana \
  -e "GF_PLUGINS_PREINSTALL=custom-plugin@@https://github.com/VolkovLabs/custom-plugin.zip" \
  grafana/grafana-enterprise

Example

The following example runs the latest stable version of Grafana, listening on port 3000, with the container named grafana, persistent storage in the grafana-storage docker volume, the server root URL set, and the official clock panel plugin installed.

# create a persistent volume for your data
docker volume create grafana-storage

# start grafana by using the above persistent storage
# and defining environment variables

docker run -d -p 3000:3000 --name=grafana \
  --volume grafana-storage:/var/lib/grafana \
  -e "GF_SERVER_ROOT_URL=http://my.grafana.server/" \
  -e "GF_PLUGINS_PREINSTALL=grafana-clock-panel" \
  grafana/grafana-enterprise

Run Grafana via Docker Compose

Docker Compose is a software tool that makes it easy to define and share applications that consist of multiple containers. It works by using a YAML file, usually called docker-compose.yaml, which lists all the services that make up the application. You can start the containers in the correct order with a single command, and with another command, you can shut them down. For more information about the benefits of using Docker Compose and how to use it refer to Use Docker Compose.

Before you begin

To run Grafana via Docker Compose, install the compose tool on your machine. To determine if the compose tool is available, run the following command:

docker compose version

If the compose tool is unavailable, refer to Install Docker Compose.

Run the latest stable version of Grafana

This section shows you how to run Grafana using Docker Compose. The examples in this section use Compose version 3. For more information about compatibility, refer to Compose and Docker compatibility matrix.

Note: If you are on a Linux system (for example, Debian or Ubuntu), you might need to add sudo before the command or add your user to the docker group. For more information, refer to Linux post-installation steps for Docker Engine.

To run the latest stable version of Grafana using Docker Compose, complete the following steps:

Create a docker-compose.yaml file.

# first go into the directory where you have created this docker-compose.yaml file
cd /path/to/docker-compose-directory

# now create the docker-compose.yaml file
touch docker-compose.yaml

Now, add the following code into the docker-compose.yaml file.

For example:

services:
  grafana:
    image: grafana/grafana-enterprise
    container_name: grafana
    restart: unless-stopped
    ports:
      - '3000:3000'

To run docker-compose.yaml, run the following command:
Bash
```
# start the grafana container
docker compose up -d
```
Where:

d = detached mode

up = to bring the container up and running

To determine that Grafana is running, open a browser window and type IP_ADDRESS:3000. The sign in screen should appear.

Stop the Grafana container

To stop the Grafana container, run the following command:

docker compose down

Note: For more information about using Docker Compose commands, refer to docker compose.

Save your Grafana data

Use Docker volumes (recommended)

Use Docker volumes when you want the Docker Engine to manage the storage volume.

To use Docker volumes for persistent storage, complete the following steps:

Create a docker-compose.yaml file

# first go into the directory where you have created this docker-compose.yaml file
cd /path/to/docker-compose-directory

# now create the docker-compose.yaml file
touch docker-compose.yaml

Add the following code into the docker-compose.yaml file.

services:
  grafana:
    image: grafana/grafana-enterprise
    container_name: grafana
    restart: unless-stopped
    ports:
      - '3000:3000'
    volumes:
      - grafana-storage:/var/lib/grafana
volumes:
  grafana-storage: {}

Save the file and run the following command:
Bash
```
docker compose up -d
```

Use bind mounts

If you plan to use directories on your host for the database or configuration when running Grafana in Docker, you must start the container with a user that has the permission to access and write to the directory you map.

To use bind mounts, complete the following steps:

Create a docker-compose.yaml file

# first go into the directory where you have created this docker-compose.yaml file
cd /path/to/docker-compose-directory

# now create the docker-compose.yaml file
touch docker-compose.yaml

Create the directory where you will be mounting your data, in this case is /data e.g. in your current working directory:
Bash
```
mkdir $PWD/data
```

Now, add the following code into the docker-compose.yaml file.

services:
  grafana:
    image: grafana/grafana-enterprise
    container_name: grafana
    restart: unless-stopped
    # if you are running as root then set it to 0
    # else find the right id with the id -u command
    user: '0'
    ports:
      - '3000:3000'
    # adding the mount volume point which we create earlier
    volumes:
      - '$PWD/data:/var/lib/grafana'

Save the file and run the following command:
Bash
```
docker compose up -d
```

Example

services:
  grafana:
    image: grafana/grafana-enterprise
    container_name: grafana
    restart: unless-stopped
    environment:
      - GF_SERVER_ROOT_URL=http://my.grafana.server/
      - GF_PLUGINS_PREINSTALL=grafana-clock-panel
    ports:
      - '3000:3000'
    volumes:
      - 'grafana_storage:/var/lib/grafana'
volumes:
  grafana_storage: {}

Note
If you want to specify the version of a plugin, add the version number to the GF_PLUGINS_PREINSTALL environment variable. For example: -e "GF_PLUGINS_PREINSTALL=grafana-clock-panel@1.0.1,grafana-simple-json-datasource@1.3.5". If you do not specify a version number, the latest version is used.

Next steps

Refer to the Getting Started guide for information about logging in, setting up data sources, and so on.

Configure Docker image

Refer to Configure a Grafana Docker image page for details on options for customizing your environment, logging, database, and so on.

Configure Grafana

Refer to the Configuration page for details on options for customizing your environment, logging, database, and so on.

Deploy Grafana on Kubernetes

Fri, 03 Apr 2026 19:43:06 +0000

Deploy Grafana on Kubernetes

On this page, you will find instructions for installing and running Grafana on Kubernetes using Kubernetes manifests for the setup. If Helm is your preferred option, refer to Grafana Helm community charts.

Watch this video to learn more about installing Grafana on Kubernetes:

Before you begin

To follow this guide:

You need the latest version of Kubernetes running either locally or remotely on a public or private cloud.
If you plan to use it in a local environment, you can use various Kubernetes options such as minikube, kind, Docker Desktop, and others.
If you plan to use Kubernetes in a production setting, it’s recommended to utilize managed cloud services like Google Kubernetes Engine (GKE), Amazon Elastic Kubernetes Service (EKS), or Azure Kubernetes Service (AKS).

System requirements

This section provides minimum hardware and software requirements.

Minimum Hardware Requirements

Disk space: 1 GB
Memory: 750 MiB (approx 750 MB)
CPU: 250m (approx 0.25 cores)

Supported databases

For a list of supported databases, refer to supported databases.

Supported web browsers

For a list of support web browsers, refer to supported web browsers.

Note
Enable port 3000 in your network environment, as this is the Grafana default port.

Deploy Grafana OSS on Kubernetes

This section explains how to install Grafana OSS using Kubernetes.

Note
If you want to install Grafana Enterprise on Kubernetes, refer to Deploy Grafana Enterprise on Kubernetes.

If you deploy an application in Kubernetes, it will use the default namespace which may already have other applications running. This can result in conflicts and other issues.

It is recommended to create a new namespace in Kubernetes to better manage, organize, allocate, and manage cluster resources. For more information about Namespaces, refer to the official Kubernetes documentation.

To create a namespace, run the following command:
Bash
```
kubectl create namespace my-grafana
```
In this example, the namespace is my-grafana
To verify and view the newly created namespace, run the following command:
Bash
```
kubectl get namespace my-grafana
```
The output of the command provides more information about the newly created namespace.

Create a YAML manifest file named grafana.yaml. This file will contain the necessary code for deployment.

touch grafana.yaml

In the next step you define the following three objects in the YAML file.

Object	Description
Persistent Volume Claim (PVC)	This object stores the data.
Service	This object provides network access to the Pod defined in the deployment.
Deployment	This object is responsible for creating the pods, ensuring they stay up to date, and managing Replicaset and Rolling updates.

Copy and paste the following contents and save it in the grafana.yaml file.

---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: grafana-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: grafana
  name: grafana
spec:
  selector:
    matchLabels:
      app: grafana
  template:
    metadata:
      labels:
        app: grafana
    spec:
      securityContext:
        fsGroup: 472
        supplementalGroups:
          - 0
      containers:
        - name: grafana
          image: grafana/grafana:latest
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 3000
              name: http-grafana
              protocol: TCP
          readinessProbe:
            failureThreshold: 3
            httpGet:
              path: /robots.txt
              port: 3000
              scheme: HTTP
            initialDelaySeconds: 10
            periodSeconds: 30
            successThreshold: 1
            timeoutSeconds: 2
          livenessProbe:
            failureThreshold: 3
            initialDelaySeconds: 30
            periodSeconds: 10
            successThreshold: 1
            tcpSocket:
              port: 3000
            timeoutSeconds: 1
          resources:
            requests:
              cpu: 250m
              memory: 750Mi
          volumeMounts:
            - mountPath: /var/lib/grafana
              name: grafana-pv
      volumes:
        - name: grafana-pv
          persistentVolumeClaim:
            claimName: grafana-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: grafana
spec:
  ports:
    - port: 3000
      protocol: TCP
      targetPort: http-grafana
  selector:
    app: grafana
  sessionAffinity: None
  type: LoadBalancer

Run the following command to send the manifest to the Kubernetes API server:
Bash
```
kubectl apply -f grafana.yaml --namespace=my-grafana
```
This command creates the PVC, Deployment, and Service objects.
Complete the following steps to verify the deployment status of each object.

a. For PVC, run the following command:
Bash
```
kubectl get pvc --namespace=my-grafana -o wide
```
b. For Deployment, run the following command:
Bash
```
kubectl get deployments --namespace=my-grafana -o wide
```
c. For Service, run the following command:
Bash
```
kubectl get svc --namespace=my-grafana -o wide
```

Access Grafana on Managed K8s Providers

In this task, you access Grafana deployed on a Managed Kubernetes provider using a web browser. Accessing Grafana via a web browser is straightforward if it is deployed on a Managed Kubernetes Provider as it uses the cloud provider’s LoadBalancer to which the external load balancer routes are automatically created.

Run the following command to obtain the deployment information:

kubectl get all --namespace=my-grafana

The output returned should look similar to the following:

NAME                           READY   STATUS    RESTARTS   AGE
pod/grafana-69946c9bd6-kwjb6   1/1     Running   0          7m27s

NAME              TYPE           CLUSTER-IP     EXTERNAL-IP      PORT(S)          AGE
service/grafana   LoadBalancer   10.5.243.226   1.120.130.330   3000:31171/TCP   7m27s

NAME                      READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/grafana   1/1     1            1           7m29s

NAME                                 DESIRED   CURRENT   READY   AGE
replicaset.apps/grafana-69946c9bd6   1         1         1       7m30s

Identify the EXTERNAL-IP value in the output and type it into your browser.

The Grafana sign-in page appears.
To sign in, enter admin for both the username and password.
If you do not see the EXTERNAL-IP, complete the following steps:

a. Run the following command to do a port-forwarding of the Grafana service on port 3000.
Bash
```
kubectl port-forward service/grafana 3000:3000 --namespace=my-grafana
```
For more information about port-forwarding, refer to Use Port Forwarding to Access Applications in a Cluster.

b. Navigate to localhost:3000 in your browser.

The Grafana sign-in page appears.

c. To sign in, enter admin for both the username and password.

Access Grafana using minikube

There are multiple ways to access the Grafana UI on a web browser when using minikube. For more information about minikube, refer to How to access applications running within minikube.

This section lists the two most common options for accessing an application running in minikube.

Option 1: Expose the service

This option uses the type: LoadBalancer in the grafana.yaml service manifest, which makes the service accessible through the minikube service command. For more information, refer to minikube Service command usage.

Run the following command to obtain the Grafana service IP:

minikube service grafana --namespace=my-grafana

The output returns the Kubernetes URL for service in your local cluster.

|------------|---------|-------------|------------------------------|
| NAMESPACE  |  NAME   | TARGET PORT |             URL              |
|------------|---------|-------------|------------------------------|
| my-grafana | grafana |        3000 | http://192.168.122.144:32182 |
|------------|---------|-------------|------------------------------|
Opening service my-grafana/grafana in default browser...
http://192.168.122.144:32182

Run a curl command to verify whether a given connection should work in a browser under ideal circumstances.
Bash
```
curl 192.168.122.144:32182
```
The following example output shows that an endpoint has been located:

<a href="/login">Found</a>.
Access the Grafana UI in the browser using the provided IP:Port from the command above. For example 192.168.122.144:32182

The Grafana sign-in page appears.
To sign in to Grafana, enter admin for both the username and password.

Option 2: Use port forwarding

If Option 1 does not work in your minikube environment (this mostly depends on the network), then as an alternative you can use the port forwarding option for the Grafana service on port 3000.

For more information about port forwarding, refer to Use Port Forwarding to Access Applications in a Cluster.

To find the minikube IP address, run the following command:
Bash
```
minikube ip
```
The output contains the IP address that you use to access the Grafana Pod during port forwarding.

A Pod is the smallest deployment unit in Kubernetes and is the core building block for running applications in a Kubernetes cluster. For more information about Pods, refer to Pods.
To obtain the Grafana Pod information, run the following command:
Bash
```
kubectl get pods --namespace=my-grafana
```
The output should look similar to the following:
Bash
```
NAME                       READY   STATUS    RESTARTS   AGE
grafana-58445b6986-dxrrw   1/1     Running   0          9m54s
```
The output shows the Grafana POD name in the NAME column, that you use for port forwarding.

Run the following command for enabling the port forwarding on the POD:

kubectl port-forward pod/grafana-58445b6986-dxrrw --namespace=my-grafana --address 0.0.0.0 3000:3000

To access the Grafana UI on the web browser, type the minikube IP along with the forwarded port. For example 192.168.122.144:3000

The Grafana sign-in page appears.
To sign in to Grafana, enter admin for both the username and password.

Update an existing deployment using a rolling update strategy

Rolling updates enable deployment updates to take place with no downtime by incrementally updating Pods instances with new ones. The new Pods will be scheduled on nodes with available resources. For more information about rolling updates, refer to Performing a Rolling Update.

The following steps use the kubectl annotate command to add the metadata and keep track of the deployment. For more information about kubectl annotate, refer to kubectl annotate documentation.

Note
Instead of using the annotate flag, you can still use the --record flag. However, it has been deprecated and will be removed in the future version of Kubernetes. See: https://github.com/kubernetes/kubernetes/issues/40422

To view the current status of the rollout, run the following command:
Bash
```
kubectl rollout history deployment/grafana --namespace=my-grafana
```
The output will look similar to this:
Bash
```
deployment.apps/grafana
REVISION  CHANGE-CAUSE
1         NONE
```
The output shows that nothing has been updated or changed after applying the grafana.yaml file.

To add metadata to keep record of the initial deployment, run the following command:

kubectl annotate deployment/grafana kubernetes.io/change-cause='deployed the default base yaml file' --namespace=my-grafana

To review the rollout history and verify the changes, run the following command:
Bash
```
kubectl rollout history deployment/grafana --namespace=my-grafana
```
You should see the updated information that you added in the CHANGE-CAUSE earlier.

Change Grafana image version

To change the deployed Grafana version, run the following kubectl edit command:
Bash
```
kubectl edit deployment grafana --namespace=my-grafana
```
In the editor, change the container image under the kind: Deployment section.

For example:
- From
  - yaml image: grafana/grafana:12.1.0
- To
  - yaml image: grafana/grafana-dev:12.2.0-17161637292
Save the changes.

Once you save the file, you receive a message similar to the following:
Bash
```
deployment.apps/grafana edited
```
This means that the changes have been applied.
To verify that the rollout on the cluster is successful, run the following command:
Bash
```
kubectl rollout status deployment grafana --namespace=my-grafana
```
A successful deployment rollout means that the Grafana Dev cluster is now available.
To check the statuses of all deployed objects, run the following command and include the -o wide flag to get more detailed output:
Bash
```
kubectl get all --namespace=my-grafana -o wide
```
You should see the newly deployed grafana-dev image.
To verify it, access the Grafana UI in the browser using the provided IP:Port from the command above.

The Grafana sign-in page appears.
To sign in to Grafana, enter admin for both the username and password.
In the top-right corner, click the help icon.

The version information appears.

Add the change cause metadata to keep track of things using the commands:

kubectl annotate deployment grafana --namespace=my-grafana kubernetes.io/change-cause='using grafana-dev:12.2.0-17161637292 for testing'

To verify, run the kubectl rollout history command:

kubectl rollout history deployment grafana --namespace=my-grafana

You will see an output similar to this:

deployment.apps/grafana
REVISION  CHANGE-CAUSE
1         deploying the default yaml
2         using grafana-dev:12.2.0-17161637292 for testing

This means that REVISION#2 is the current version.

Note
The last line of the kubectl rollout history deployment command output is the one which is currently active and running on your Kubernetes environment.

Roll back a deployment

When the Grafana deployment becomes unstable due to crash looping, bugs, and so on, you can roll back a deployment to an earlier version (a REVISION).

By default, Kubernetes deployment rollout history remains in the system so that you can roll back at any time. For more information, refer to Rolling Back to a Previous Revision.

To list all possible REVISION values, run the following command:
Bash
```
kubectl rollout history deployment grafana --namespace=my-grafana
```
To roll back to a previous version, run the kubectl rollout undo command and provide a revision number.

Example: To roll back to a previous version, specify the REVISION number, which appears after you run the kubectl rollout history deployment command, in the --to-revision parameter.
Bash
```
kubectl rollout undo deployment grafana --to-revision=1 --namespace=my-grafana
```
To verify that the rollback on the cluster is successful, run the following command:
Bash
```
kubectl rollout status deployment grafana --namespace=my-grafana
```
Access the Grafana UI in the browser using the provided IP:Port from the command above.

The Grafana sign-in page appears.
To sign in to Grafana, enter admin for both the username and password.
In the top-right corner, click the help icon to display the version number.
To see the new rollout history, run the following command:
Bash
```
kubectl rollout history deployment grafana --namespace=my-grafana
```

If you need to go back to any other REVISION, just repeat the steps above and use the correct revision number in the --to-revision parameter.

Provision Grafana resources using configuration files

Provisioning can add, update, or delete resources specified in your configuration files when Grafana starts. For detailed information, refer to Grafana Provisioning.

This section outlines general instructions for provisioning Grafana resources within Kubernetes, using a persistent volume to supply the configuration files to the Grafana pod.

Add a new PersistentVolumeClaim to the grafana.yaml file.

---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: grafana-provisioning-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Mi

In the grafana.yaml file, mount the persistent volume into /etc/grafana/provisioning as follows.

...
    volumeMounts:
      - mountPath: /etc/grafana/provisioning
        name: grafana-provisioning-pv
      ...
volumes:
  - name: grafana-provisioning-pv
    persistentVolumeClaim:
      claimName: grafana-provisioning-pvc
...

Find or create the provision resources you want to add. For instance, create a alerting.yaml file adding a mute timing (alerting resource).
YAML
```
apiVersion: 1
muteTimes:
  - orgId: 1
    name: MuteWeekends
    time_intervals:
      - weekdays: [saturday, sunday]
```
By default, configuration files for alerting resources need to be placed in the provisioning/alerting directory.

Save the alerting.yaml file in a directory named alerting, as we will next supply this alerting directory to the /etc/grafana/provisioning folder of the Grafana pod.
Verify first the content of the provisioning directory in the running Grafana pod.
Bash
```
kubectl exec -n my-grafana <pod_name> -- ls /etc/grafana/provisioning/
```
Bash
```
kubectl exec -n my-grafana <pod_name> -- ls /etc/grafana/provisioning/alerting
```
Because the alerting folder is not available yet, the last command should output a No such file or directory error.
Copy the local alerting directory to /etc/grafana/provisioning/ in the Grafana pod.
Bash
```
kubectl cp alerting my-grafana/<pod_name>:/etc/grafana/provisioning/
```
You can follow the same process to provision additional Grafana resources by supplying the following folders:
- provisioning/dashboards
- provisioning/datasources
- provisioning/plugins
Verify the alerting directory in the running Grafana pod includes the alerting.yaml file.
Bash
```
kubectl exec -n my-grafana <pod_name> -- ls /etc/grafana/provisioning/alerting
```
Restart the Grafana pod to provision the resources.
Bash
```
kubectl rollout restart -n my-grafana deployment --selector=app=grafana
```
Note that rollout restart kills the previous pod and scales a new pod. When the old pod terminates, you may have to enable port-forwarding in the new pod. For instructions, refer to the previous sections about port forwarding in this guide.
Verify the Grafana resources are properly provisioned within the Grafana instance.

Troubleshooting

This section includes troubleshooting tips you might find helpful when deploying Grafana on Kubernetes.

Collecting logs

It is important to view the Grafana server logs while troubleshooting any issues.

To check the Grafana logs, run the following command:

# dump Pod logs for a Deployment (single-container case)
kubectl logs --namespace=my-grafana deploy/grafana

If you have multiple containers running in the deployment, run the following command to obtain the logs only for the Grafana deployment:
Bash
```
# dump Pod logs for a Deployment (multi-container case)
kubectl logs --namespace=my-grafana deploy/grafana -c grafana
```

For more information about accessing Kubernetes application logs, refer to Pods and Deployments.

Increasing log levels to debug mode

By default, the Grafana log level is set to info, but you can increase it to debug mode to fetch information needed to diagnose and troubleshoot a problem. For more information about Grafana log levels, refer to Configuring logs.

The following example uses the Kubernetes ConfigMap which is an API object that stores non-confidential data in key-value pairs. For more information, refer to Kubernetes ConfigMap Concept.

Create a empty file and name it grafana.ini and add the following:
Bash
```
[log]
; # Either "debug", "info", "warn", "error", "critical", default is "info"
; # we change from info to debug level
level = debug
```
This example adds the portion of the log section from the configuration file. You can refer to the Configure Grafana documentation to view all the default configuration settings.
To add the configuration file into the Kubernetes cluster via the ConfigMap object, run the following command:
Bash
```
kubectl create configmap ge-config --from-file=/path/to/file/grafana.ini --namespace=my-grafana
```
To verify the ConfigMap object creation, run the following command:
Bash
```
kubectl get configmap --namespace=my-grafana
```

Open the grafana.yaml file and In the Deployment section, provide the mount path to the custom configuration (/etc/grafana) and reference the newly created ConfigMap for it.

---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: grafana
  name: grafana
# the rest of the code remains the same.
...
....
...
            requests:
            cpu: 250m
            memory: 750Mi
        volumeMounts:
          - mountPath: /var/lib/grafana
            name: grafana-pv
           # This is to mount the volume for the custom configuration
          - mountPath: /etc/grafana
            name: ge-config
    volumes:
      - name: grafana-pv
        persistentVolumeClaim:
          claimName: grafana-pvc
       # This is to provide the reference to the ConfigMap for the volume
      - name: ge-config
        configMap:
          name: ge-config

Deploy the manifest using the following kubectl apply command:
Bash
```
kubectl apply -f grafana.yaml --namespace=my-grafana
```

To verify the status, run the following commands:

# first check the rollout status
kubectl rollout status deployment grafana --namespace=my-grafana

# then check the deployment and configMap information
kubectl get all --namespace=my-grafana

To verify it, access the Grafana UI in the browser using the provided IP:Port

The Grafana sign-in page appears.
To sign in to Grafana, enter admin for both the username and password.
Navigate to Server Admin > Settings and then search for log.

You should see the level to debug mode.

Using the –dry-run command

You can use the Kubernetes --dry-run command to send requests to modifying endpoints and determine if the request would have succeeded.

Performing a dry run can be useful for catching errors or unintended consequences before they occur. For more information, refer to Kubernetes Dry-run.

Example:

The following example shows how to perform a dry run when you make changes to the grafana.yaml such as using a new image version, or adding new labels and you want to determine if there are syntax errors or conflicts.

To perform a dry run, run the following command:

kubectl apply -f grafana.yaml --dry-run=server --namespace=grafana

If there are no errors, then the output will look similar to this:

persistentvolumeclaim/grafana-pvc unchanged (server dry run)
deployment.apps/grafana unchanged (server dry run)
service/grafana unchanged (server dry run)

If there are errors or warnings, you will see them in the terminal.

Remove Grafana

If you want to remove any of the Grafana deployment objects, use the kubectl delete command.

If you want to remove the complete Grafana deployment, run the following command:
Bash
```
kubectl delete -f grafana.yaml --namespace=my-grafana
```
This command deletes the deployment, persistentvolumeclaim, and service objects.
To delete the ConfigMap, run the following command:
Bash
```
kubectl delete configmap ge-config --namespace=my-grafana
```

Deploy Grafana Enterprise on Kubernetes

The process for deploying Grafana Enterprise is almost identical to the preceding process, except for additional steps that are required for adding your license file.

Obtain Grafana Enterprise license

To run Grafana Enterprise, you need a valid license. To obtain a license, contact a Grafana Labs representative. This topic assumes that you have a valid license in a license.jwt file. Associate your license with a URL that you can use later in the topic.

Create license secret

Create a Kubernetes secret from your license file using the following command:

kubectl create secret generic ge-license --from-file=/path/to/your/license.jwt

Create Grafana Enterprise configuration

Create a Grafana configuration file with the name grafana.ini

Paste the following YAML contents into the file you created:

[enterprise]
license_path = /etc/grafana/license/license.jwt
[server]
root_url =/your/license/root/url

Update the root_url field to the url associated with the license provided to you.

Create Configmap for Grafana Enterprise configuration

Create a Kubernetes Configmap from your grafana.ini file with the following command:

kubectl create configmap ge-config --from-file=/path/to/your/grafana.ini

Create Grafana Enterprise Kubernetes manifest

Create a grafana.yaml file, and copy-and-paste the following content into it.

The following YAML is identical to the one for a Grafana installation, except for the additional references to the Configmap that contains your Grafana configuration file and the secret that has your license.

---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: grafana-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: grafana
  name: grafana
spec:
  selector:
    matchLabels:
      app: grafana
  template:
    metadata:
      labels:
        app: grafana
    spec:
      securityContext:
        fsGroup: 472
        supplementalGroups:
          - 0
      containers:
        - image: grafana/grafana-enterprise:latest
          imagePullPolicy: IfNotPresent
          name: grafana
          ports:
            - containerPort: 3000
              name: http-grafana
              protocol: TCP
          readinessProbe:
            failureThreshold: 3
            httpGet:
              path: /robots.txt
              port: 3000
              scheme: HTTP
            initialDelaySeconds: 10
            periodSeconds: 30
            successThreshold: 1
            timeoutSeconds: 2
          resources:
            limits:
              memory: 4Gi
            requests:
              cpu: 100m
              memory: 2Gi
          volumeMounts:
            - mountPath: /var/lib/grafana
              name: grafana-pv
            - mountPath: /etc/grafana
              name: ge-config
            - mountPath: /etc/grafana/license
              name: ge-license
      volumes:
        - name: grafana-pv
          persistentVolumeClaim:
            claimName: grafana-pvc
        - name: ge-config
          configMap:
            name: ge-config
        - name: ge-license
          secret:
            secretName: ge-license
---
apiVersion: v1
kind: Service
metadata:
  name: grafana
spec:
  ports:
    - port: 3000
      protocol: TCP
      targetPort: http-grafana
  selector:
    app: grafana
  sessionAffinity: None
  type: LoadBalancer

Caution
If you use LoadBalancer in the Service and depending on your cloud platform and network configuration, doing so might expose your Grafana instance to the Internet. To eliminate this risk, use ClusterIP to restrict access from within the cluster Grafana is deployed to.

To send the manifest to Kubernetes API Server, run the following command: kubectl apply -f grafana.yaml
To verify the manifest was sent, run the following command: kubectl port-forward service/grafana 3000:3000
Navigate to localhost:3000 in your browser.

You should see the Grafana login page.
Use admin for both the username and password to login.
To verify you are working with an enterprise license, scroll to the bottom of the page where you should see Enterprise (Licensed).

Deploy Grafana using Helm Charts

Fri, 03 Apr 2026 19:43:06 +0000

Deploy Grafana using Helm Charts

This topic includes instructions for installing and running Grafana on Kubernetes using Helm Charts.

Helm is an open source command line tool used for managing Kubernetes applications. It is a graduate project in the CNCF Landscape.

Note
The Grafana open source community offers Helm Charts for running it on Kubernetes. Please be aware that the code is provided without any warranties. If you encounter any problems, you can report them to the Community-maintained GitHub repository.

Watch this video to learn more about installing Grafana using Helm Charts:

Before you begin

To install Grafana using Helm, ensure you have completed the following:

Install a Kubernetes server on your machine. For information about installing Kubernetes, refer to Install Kubernetes.
Install the latest stable version of Helm. For information on installing Helm, refer to Install Helm.

Install Grafana using Helm

When you install Grafana using Helm, you complete the following tasks:

Set up the Grafana Helm repository, which provides a space in which you will install Grafana.
Deploy Grafana using Helm, which installs Grafana into a namespace.
Accessing Grafana, which provides steps to sign into Grafana.

Set up the Grafana Helm repository

To set up the Grafana Helm repository so that you download the correct Grafana Helm charts on your machine, complete the following steps:

To add the Grafana repository, use the following command syntax:

helm repo add <DESIRED-NAME> <HELM-REPO-URL>

The following example adds the grafana Helm repository.
Bash
```
helm repo add grafana-community https://grafana-community.github.io/helm-charts
```
Run the following command to verify the repository was added:
Bash
```
helm repo list
```
After you add the repository, you should see an output similar to the following:
Bash
```
NAME              URL
grafana-community https://grafana-community.github.io/helm-charts
```
Run the following command to update the repository to download the latest Grafana Helm charts:
Bash
```
helm repo update
```

Deploy the Grafana Helm charts

After you have set up the Grafana Helm repository, you can start to deploy it on your Kubernetes cluster.

When you deploy Grafana Helm charts, use a separate namespace instead of relying on the default namespace. The default namespace might already have other applications running, which can lead to conflicts and other potential issues.

When you create a new namespace in Kubernetes, you can better organize, allocate, and manage cluster resources. For more information, refer to Namespaces.

To create a namespace, run the following command:
Bash
```
kubectl create namespace monitoring
```
You will see an output similar to this, which means that the namespace has been successfully created:
Bash
```
namespace/monitoring created
```
Search for the official grafana-community/grafana repository using the command:

helm search repo <repo-name/package-name>

For example, the following command provides a list of the Grafana Helm Charts from which you will install the latest version of the Grafana chart.
Bash
```
helm search repo grafana-community/grafana
```
Run the following command to deploy the Grafana Helm Chart inside your namespace.
Bash
```
helm install my-grafana grafana-community/grafana --namespace monitoring
```
Where:
- helm install: Installs the chart by deploying it on the Kubernetes cluster
- my-grafana: The logical chart name that you provided
- grafana-community/grafana: The repository and package name to install
- --namespace: The Kubernetes namespace (i.e. monitoring) where you want to deploy the chart

To verify the deployment status, run the following command and verify that deployed appears in the STATUS column:

helm list -n monitoring

You should see an output similar to the following:

NAME            NAMESPACE       REVISION        UPDATED                                 STATUS          CHART          APP VERSION
my-grafana      monitoring      1               2024-01-13 23:06:42.737989554 +0000 UTC deployed        grafana-6.59.0 10.1.0

To check the overall status of all the objects in the namespace, run the following command:
Bash
```
kubectl get all -n monitoring
```
If you encounter errors or warnings in the STATUS column, check the logs and refer to the Troubleshooting section of this documentation.

Access Grafana

This section describes the steps you must complete to access Grafana via web browser.

Run the following helm get notes command:
Bash
```
helm get notes my-grafana -n monitoring
```
This command will print out the chart notes. You will the output NOTES that provide the complete instructions about:
- How to decode the login password for the Grafana admin account
- Access Grafana service to the web browser
To get the Grafana admin password, run the command as follows:
Bash
```
kubectl get secret --namespace monitoring my-grafana -o jsonpath="{.data.admin-password}" | base64 --decode ; echo
```
It will give you a decoded base64 string output which is the password for the admin account.
Save the decoded password to a file on your machine.
To access Grafana service on the web browser, run the following command:
Bash
```
export POD_NAME=$(kubectl get pods --namespace monitoring -l "app.kubernetes.io/name=grafana,app.kubernetes.io/instance=my-grafana" -o jsonpath="{.items[0].metadata.name}")
```
The above command will export a shell variable named POD_NAME that will save the complete name of the pod which got deployed.
Run the following port forwarding command to direct the Grafana pod to listen to port 3000:
Bash
```
kubectl --namespace monitoring port-forward $POD_NAME 3000
```
For more information about port-forwarding, refer to Use Port Forwarding to Access Applications in a Cluster.
Navigate to 127.0.0.1:3000 in your browser.
The Grafana sign-in page appears.
To sign in, enter admin for the username.
For the password paste it which you have saved to a file after decoding it earlier.

Customize Grafana default configuration

Helm is a popular package manager for Kubernetes. It bundles Kubernetes resource manifests to be re-used across different environments. These manifests are written in a templating language, allowing you to provide configuration values via values.yaml file, or in-line using Helm, to replace the placeholders in the manifest where these configurations should reside.

The values.yaml file allows you to customize the chart’s configuration by specifying values for various parameters such as image versions, resource limits, service configurations, etc.

By modifying the values in the values.yaml file, you can tailor the deployment of a Helm chart to your specific requirements by using the helm install or upgrade commands. For more information about configuring Helm, refer to Values Files.

Download the values.yaml file

In order to make any configuration changes, download the values.yaml file from the Grafana Helm Charts repository:

https://github.com/grafana-community/helm-charts/blob/main/charts/grafana/values.yaml

Note
Depending on your use case requirements, you can use a single YAML file that contains your configuration changes or you can create multiple YAML files.

Enable persistent storage (recommended)

By default, persistent storage is disabled, which means that Grafana uses ephemeral storage, and all data will be stored within the container’s file system. This data will be lost if the container is stopped, restarted, or if the container crashes.

It is highly recommended that you enable persistent storage in Grafana Helm charts if you want to ensure that your data persists and is not lost in case of container restarts or failures.

Enabling persistent storage in Grafana Helm charts ensures a reliable solution for running Grafana in production environments.

To enable the persistent storage in the Grafana Helm charts, complete the following steps:

Open the values.yaml file in your favorite editor.

Edit the values and under the section of persistence, change the enable flag from false to true

.......
............
......
persistence:
  type: pvc
  enabled: true
  # storageClassName: default
.......
............
......

Run the following helm upgrade command by specifying the values.yaml file to make the changes take effect:
Bash
```
helm upgrade my-grafana grafana-community/grafana -f values.yaml -n monitoring
```

The PVC will now store all your data such as dashboards, data sources, and so on.

Install plugins (e.g. Zabbix app, Clock panel, etc.)

You can install plugins in Grafana from the official and community plugins page. These plugins allow you to add new visualization types, data sources, and applications to help you better visualize your data.

Grafana currently supports three types of plugins: panel, data source, and app. For more information on managing plugins, refer to Plugin Management.

To install plugins in the Grafana Helm Charts, complete the following steps:

Open the values.yaml file in your favorite editor.

Find the line that says plugins: and under that section, define the plugins that you want to install.

.......
............
......
plugins:
# here we are installing two plugins, make sure to keep the indentation correct as written here.

- alexanderzobnin-zabbix-app
- grafana-clock-panel
.......
............
......

Save the changes and use the helm upgrade command to get these plugins installed:
Bash
```
helm upgrade my-grafana grafana-community/grafana -f values.yaml -n monitoring
```
Navigate to 127.0.0.1:3000 in your browser.
Login with admin credentials when the Grafana sign-in page appears.
Navigate to UI -> Administration -> Plugins
Search for the above plugins and they should be marked as installed.

Configure a Private CA (Certificate Authority)

In many enterprise networks, TLS certificates are issued by a private certificate authority and are not trusted by default (using the provided OS trust chain).

If your Grafana instance needs to interact with services exposing certificates issued by these private CAs, then you need to ensure Grafana trusts the root certificate.

You might need to configure this if you:

have plugins that require connectivity to other self hosted systems. For example, if you’ve installed the Grafana Enterprise Metrics, Logs, or Traces (GEM, GEL, GET) plugins, and your GEM (or GEL/GET) cluster is using a private certificate.
want to connect to data sources which are listening on HTTPS with a private certificate.
are using a backend database for persistence, or caching service that uses private certificates for encryption in transit.

In some cases you can specify a self-signed certificate within Grafana (such as in some data sources), or choose to skip TLS certificate validation (this is not recommended unless absolutely necessary).

A simple solution which should work across your entire instance (plugins, data sources, and backend connections) is to add your self-signed CA certificate to your Kubernetes deployment.

Create a ConfigMap containing the certificate, and deploy it to your Kubernetes cluster

# grafana-ca-configmap.yaml
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: grafana-ca-cert
data:
  ca.pem: |
    -----BEGIN CERTIFICATE-----
    (rest of the CA cert)
    -----END CERTIFICATE-----

kubectl apply --filename grafana-ca-configmap.yaml --namespace monitoring

Open the Helm values.yaml file in your favorite editor.

Find the line that says extraConfigmapMounts: and under that section, specify the additional ConfigMap that you want to mount.

.......
............
......
extraConfigmapMounts:
   - name: ca-certs-configmap
     mountPath: /etc/ssl/certs/ca.pem
     subPath: ca.pem
     configMap: grafana-ca-cert
     readOnly: true
.......
............
......

Save the changes and use the helm upgrade command to update your Grafana deployment and mount the new ConfigMap:
Bash
```
helm upgrade my-grafana grafana-community/grafana --values values.yaml --namespace monitoring
```

Troubleshooting

This section includes troubleshooting tips you might find helpful when deploying Grafana on Kubernetes via Helm.

Collect logs

It is important to view the Grafana server logs while troubleshooting any issues.

To check the Grafana logs, run the following command:

# dump Pod logs for a Deployment (single-container case)

kubectl logs --namespace=monitoring deploy/my-grafana

If you have multiple containers running in the deployment, run the following command to obtain the logs only for the Grafana deployment:

# dump Pod logs for a Deployment (multi-container case)

kubectl logs --namespace=monitoring deploy/grafana -c my-grafana

For more information about accessing Kubernetes application logs, refer to Pods and Deployments.

Increase log levels

To increase log level to debug mode, use the following steps:

Open the values.yaml file in your favorite editor and search for the string grafana.ini and there you will find a section about log mode.

Add level: debug just below the line mode: console

# This is the values.yaml file
   .....
.......
....
grafana.ini:
paths:
   data: /var/lib/grafana/
   .....
.......
....
   mode: console
   level: debug

Make sure to keep the indentation level the same otherwise it will not work.

Now to apply this, run the helm upgrade command as follows:

helm upgrade my-grafana grafana-community/grafana -f values.yaml -n monitoring

To verify it, access the Grafana UI in the browser using the provided IP:Port. The Grafana sign-in page appears.
To sign in to Grafana, enter admin for the username and paste the password which was decoded earlier. Navigate to Server Admin > Settings and then search for log. You should see the level to debug mode.

By default the login credentials for the super admin account are generated via secrets. However, this can be changed easily. To achieve this, use the following steps:

Edit the values.yaml file and search for the string adminPassword. There you can define a new password:

# Administrator credentials when not using an existing secret (see below)
adminUser: admin
adminPassword: admin

Then use the helm upgrade command as follows:
Bash
```
helm upgrade my-grafana grafana-community/grafana -f values.yaml -n monitoring
```
This command will now make your super admin login credentials as admin for both username and password.
To verify it, sign in to Grafana, enter admin for both username and password. You should be able to login as super admin.

Uninstall the Grafana deployment

To uninstall the Grafana deployment, run the command:

helm uninstall <RELEASE-NAME> <NAMESPACE-NAME>

helm uninstall my-grafana -n monitoring

This deletes all of the objects from the given namespace monitoring.

If you want to delete the namespace monitoring, then run the command:

kubectl delete namespace monitoring

Install Grafana on macOS

Fri, 03 Apr 2026 19:43:06 +0000

Install Grafana on macOS

This page explains how to install Grafana on macOS.

The following video demonstrates how to install Grafana on macOS as outlined in this document:

Install Grafana on macOS using Homebrew

To install Grafana on macOS using Homebrew, complete the following steps:

On the Homebrew homepage, search for Grafana.

The last stable and released version is listed.
Open a terminal and run the following commands:
```
brew update
brew install grafana
```
The brew page downloads and untars the files into:
- /usr/local/Cellar/grafana/[version] (Intel Silicon)
- /opt/homebrew/Cellar/grafana/[version] (Apple Silicon)
To start Grafana, run the following command:
Bash
```
brew services start grafana
```

Using the Grafana CLI with Homebrew

To use the Grafana CLI with Homebrew, you need to append the home path, the config file path and - based on the command - some other configurations to the cli command:

For admin commands, you need to append the --configOverrides cfg:default.paths.data=/opt/homebrew/var/lib/grafana configuration. Example:

/opt/homebrew/opt/grafana/bin/grafana cli --config /opt/homebrew/etc/grafana/grafana.ini --homepath /opt/homebrew/opt/grafana/share/grafana --configOverrides cfg:default.paths.data=/opt/homebrew/var/lib/grafana admin reset-admin-password <new password>

For plugins commands, you need to append the --pluginsDir /opt/homebrew/var/lib/grafana/plugins configuration. Example:

/opt/homebrew/opt/grafana/bin/grafana cli --config /opt/homebrew/etc/grafana/grafana.ini --homepath /opt/homebrew/opt/grafana/share/grafana --pluginsDir "/opt/homebrew/var/lib/grafana/plugins" plugins install <plugin-id>

Install standalone macOS binaries

To install Grafana on macOS using the standalone binaries, complete the following steps:

Navigate to the Grafana download page.
Select the Grafana version you want to install.
- The most recent Grafana version is selected by default.
- The Version field displays only tagged releases. If you want to install a nightly build, click Nightly Builds and then select a version.
Select an Edition.
- Enterprise: This is the recommended version. It is functionally identical to the open source version, but includes features you can unlock with a license, if you so choose.
- Open Source: This version is functionally identical to the Enterprise version, but you will need to download the Enterprise version if you want Enterprise features.
Click Mac.
Copy and paste the code from the download page into your command line and run.
Untar the gz file and copy the files to the location of your preference.
To start Grafana service, go to the directory and run the command:
Bash
```
./bin/grafana server
```

Alternatively, watch the Grafana for Beginners video below:

Next steps

Start the Grafana server

Install Grafana on Windows

Fri, 03 Apr 2026 19:43:06 +0000

Install Grafana on Windows

The following video demonstrates how to install Grafana using the Windows standalone installer as outlined in this document:

You install Grafana using the Windows installer or using the standalone Windows binary file.

Navigate to the Grafana download page.
Select the Grafana version you want to install.
- The most recent Grafana version is selected by default.
- The Version field displays only tagged releases. If you want to install a nightly build, click Nightly Builds and then select a version.
Select an Edition.
- Enterprise: This is the recommended version. It is functionally identical to the open source version, but includes features you can unlock with a license, if you so choose.
- Open Source: This version is functionally identical to the Enterprise version, but you will need to download the Enterprise version if you want Enterprise features.
Click Windows.
To use the Windows installer, complete the following steps:

a. Click Download the installer.

b. Open and run the installer.
To install the standalone Windows binary, complete the following steps:

a. Click Download the zip file.

b. Right-click the downloaded file, select Properties, select the unblock checkbox, and click OK.

c. Extract the ZIP file to any folder.

Start Grafana by executing grafana-server.exe, located in the bin directory, preferably from the command line. If you want to run Grafana as a Windows service, then download NSSM. It is very easy to add Grafana as a Windows service using that tool.

To run Grafana, open your browser and go to the Grafana port (http://localhost:3000/ is default) and then follow the instructions in Getting Started.

Note: The default Grafana port is 3000. This port might require extra permissions on Windows. If it does not appear in the default port, you can change the port number.
To change the port, perform the following steps:

a. Open the conf directory and copy sample.ini to custom.ini.

Note: You should edit custom.ini, never defaults.ini.

b. Edit custom.ini and uncomment the http_port configuration option.

; is the comment character in ini files.

c. Change the port to 8080 or something similar.

Port 8080 should not require extra Windows privileges.

Next steps

Start the Grafana server