diff --git a/installers/charm/grafana/.gitignore b/installers/charm/grafana/.gitignore
new file mode 100644
index 0000000..3ca6f3a
--- /dev/null
+++ b/installers/charm/grafana/.gitignore
@@ -0,0 +1,28 @@
+# Copyright 2021 Canonical Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact: legal@canonical.com
+#
+# To get in touch with the maintainers, please contact:
+# osm-charmers@lists.launchpad.net
+##
+
+venv
+.vscode
+build
+grafana.charm
+.coverage
+.stestr
+cover
diff --git a/installers/charm/grafana/.yamllint.yaml b/installers/charm/grafana/.yamllint.yaml
new file mode 100644
index 0000000..f3ecd3a
--- /dev/null
+++ b/installers/charm/grafana/.yamllint.yaml
@@ -0,0 +1,33 @@
+# Copyright 2021 Canonical Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact: legal@canonical.com
+#
+# To get in touch with the maintainers, please contact:
+# osm-charmers@lists.launchpad.net
+##
+
+---
+extends: default
+
+yaml-files:
+  - "*.yaml"
+  - "*.yml"
+  - ".yamllint"
+ignore: |
+  .tox
+  build/
+  mod/
+  lib/
diff --git a/installers/charm/grafana/README.md b/installers/charm/grafana/README.md
new file mode 100644
index 0000000..1cc1fb7
--- /dev/null
+++ b/installers/charm/grafana/README.md
@@ -0,0 +1,23 @@
+<!-- Copyright 2021 Canonical Ltd.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may
+not use this file except in compliance with the License. You may obtain
+a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+License for the specific language governing permissions and limitations
+under the License.
+
+For those usages not covered by the Apache License, Version 2.0 please
+contact: legal@canonical.com
+
+To get in touch with the maintainers, please contact:
+osm-charmers@lists.launchpad.net -->
+
+# Grafana operator Charm for Kubernetes
+
+## Requirements
diff --git a/installers/charm/grafana/config.yaml b/installers/charm/grafana/config.yaml
new file mode 100644
index 0000000..4131949
--- /dev/null
+++ b/installers/charm/grafana/config.yaml
@@ -0,0 +1,46 @@
+# Copyright 2021 Canonical Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact: legal@canonical.com
+#
+# To get in touch with the maintainers, please contact:
+# osm-charmers@lists.launchpad.net
+##
+
+options:
+  max_file_size:
+    type: int
+    description: |
+      The maximum file size, in megabytes. If there is a reverse proxy in front
+      of Keystone, it may need to be configured to handle the requested size.
+      Note: if set to 0, there is no limit.
+    default: 0
+  ingress_whitelist_source_range:
+    type: string
+    description: |
+      A comma-separated list of CIDRs to store in the
+      ingress.kubernetes.io/whitelist-source-range annotation.
+
+      This can be used to lock down access to
+      Keystone based on source IP address.
+    default: ""
+  tls_secret_name:
+    type: string
+    description: TLS Secret name
+    default: ""
+  site_url:
+    type: string
+    description: Ingress URL
+    default: ""
diff --git a/installers/charm/grafana/metadata.yaml b/installers/charm/grafana/metadata.yaml
new file mode 100644
index 0000000..c06a851
--- /dev/null
+++ b/installers/charm/grafana/metadata.yaml
@@ -0,0 +1,43 @@
+# Copyright 2021 Canonical Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact: legal@canonical.com
+#
+# To get in touch with the maintainers, please contact:
+# osm-charmers@lists.launchpad.net
+##
+
+name: grafana
+summary: OSM Grafana
+description: |
+  A CAAS charm to deploy OSM's Grafana.
+series:
+  - kubernetes
+tags:
+  - kubernetes
+  - osm
+  - grafana
+min-juju-version: 2.8.0
+deployment:
+  type: stateless
+  service: cluster
+resources:
+  image:
+    type: oci-image
+    description: Ubuntu LTS image for Grafana
+    upstream-source: "ubuntu/grafana:latest"
+requires:
+  prometheus:
+    interface: prometheus
diff --git a/installers/charm/grafana/requirements.txt b/installers/charm/grafana/requirements.txt
new file mode 100644
index 0000000..884cf9f
--- /dev/null
+++ b/installers/charm/grafana/requirements.txt
@@ -0,0 +1,23 @@
+# Copyright 2021 Canonical Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact: legal@canonical.com
+#
+# To get in touch with the maintainers, please contact:
+# osm-charmers@lists.launchpad.net
+##
+
+ops
+git+https://github.com/juju-solutions/resource-oci-image/@c5778285d332edf3d9a538f9d0c06154b7ec1b0b#egg=oci-image
diff --git a/installers/charm/grafana/src/charm.py b/installers/charm/grafana/src/charm.py
new file mode 100755
index 0000000..1920e76
--- /dev/null
+++ b/installers/charm/grafana/src/charm.py
@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+# Copyright 2021 Canonical Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact: legal@canonical.com
+#
+# To get in touch with the maintainers, please contact:
+# osm-charmers@lists.launchpad.net
+##
+
+import logging
+from typing import Dict, List, NoReturn
+
+from ops.charm import CharmBase
+from ops.framework import StoredState
+from ops.main import main
+from ops.model import ActiveStatus, Application, BlockedStatus, MaintenanceStatus, Unit
+from oci_image import OCIImageResource, OCIImageResourceError
+
+from pod_spec import make_pod_spec
+
+logger = logging.getLogger(__name__)
+
+GRAFANA_PORT = 3000
+
+
+class RelationsMissing(Exception):
+    def __init__(self, missing_relations: List):
+        self.message = ""
+        if missing_relations and isinstance(missing_relations, list):
+            self.message += f'Waiting for {", ".join(missing_relations)} relation'
+            if "," in self.message:
+                self.message += "s"
+
+
+class RelationDefinition:
+    def __init__(self, relation_name: str, keys: List, source_type):
+        if source_type != Application and source_type != Unit:
+            raise TypeError(
+                "source_type should be ops.model.Application or ops.model.Unit"
+            )
+        self.relation_name = relation_name
+        self.keys = keys
+        self.source_type = source_type
+
+
+def check_missing_relation_data(
+    data: Dict,
+    expected_relations_data: List[RelationDefinition],
+):
+    missing_relations = []
+    for relation_data in expected_relations_data:
+        if not all(
+            f"{relation_data.relation_name}_{k}" in data for k in relation_data.keys
+        ):
+            missing_relations.append(relation_data.relation_name)
+    if missing_relations:
+        raise RelationsMissing(missing_relations)
+
+
+def get_relation_data(
+    charm: CharmBase,
+    relation_data: RelationDefinition,
+) -> Dict:
+    data = {}
+    relation = charm.model.get_relation(relation_data.relation_name)
+    if relation:
+        self_app_unit = (
+            charm.app if relation_data.source_type == Application else charm.unit
+        )
+        expected_type = relation_data.source_type
+        for app_unit in relation.data:
+            if app_unit != self_app_unit and isinstance(app_unit, expected_type):
+                if all(k in relation.data[app_unit] for k in relation_data.keys):
+                    for k in relation_data.keys:
+                        data[f"{relation_data.relation_name}_{k}"] = relation.data[
+                            app_unit
+                        ].get(k)
+                    break
+    return data
+
+
+class GrafanaCharm(CharmBase):
+    """Grafana Charm."""
+
+    state = StoredState()
+
+    def __init__(self, *args) -> NoReturn:
+        """Grafana Charm constructor."""
+        super().__init__(*args)
+
+        # Internal state initialization
+        self.state.set_default(pod_spec=None)
+
+        self.port = GRAFANA_PORT
+        self.image = OCIImageResource(self, "image")
+
+        # Registering regular events
+        self.framework.observe(self.on.start, self.configure_pod)
+        self.framework.observe(self.on.config_changed, self.configure_pod)
+
+        # Registering required relation events
+        self.framework.observe(self.on.prometheus_relation_changed, self.configure_pod)
+
+        # Registering required relation broken events
+        self.framework.observe(self.on.prometheus_relation_broken, self.configure_pod)
+
+    @property
+    def relations_requirements(self):
+        return [RelationDefinition("prometheus", ["host", "port"], Unit)]
+
+    def get_relation_state(self):
+        relation_state = {}
+        for relation_requirements in self.relations_requirements:
+            data = get_relation_data(self, relation_requirements)
+            relation_state = {**relation_state, **data}
+        check_missing_relation_data(relation_state, self.relations_requirements)
+        return relation_state
+
+    def configure_pod(self, _=None) -> NoReturn:
+        """Assemble the pod spec and apply it, if possible.
+
+        Args:
+            event (EventBase): Hook or Relation event that started the
+                               function.
+        """
+        if not self.unit.is_leader():
+            self.unit.status = ActiveStatus("ready")
+            return
+
+        relation_state = None
+        try:
+            relation_state = self.get_relation_state()
+        except RelationsMissing as exc:
+            logger.exception("Relation missing error")
+            self.unit.status = BlockedStatus(exc.message)
+            return
+
+        self.unit.status = MaintenanceStatus("Assembling pod spec")
+
+        # Fetch image information
+        try:
+            self.unit.status = MaintenanceStatus("Fetching image information")
+            image_info = self.image.fetch()
+        except OCIImageResourceError:
+            self.unit.status = BlockedStatus("Error fetching image information")
+            return
+
+        try:
+            pod_spec = make_pod_spec(
+                image_info,
+                self.model.config,
+                relation_state,
+                self.model.app.name,
+                self.port,
+            )
+        except ValueError as exc:
+            logger.exception("Config/Relation data validation error")
+            self.unit.status = BlockedStatus(str(exc))
+            return
+
+        if self.state.pod_spec != pod_spec:
+            self.model.pod.set_spec(pod_spec)
+            self.state.pod_spec = pod_spec
+
+        self.unit.status = ActiveStatus("ready")
+
+
+if __name__ == "__main__":
+    main(GrafanaCharm)
diff --git a/installers/charm/grafana/src/pod_spec.py b/installers/charm/grafana/src/pod_spec.py
new file mode 100644
index 0000000..9915a9e
--- /dev/null
+++ b/installers/charm/grafana/src/pod_spec.py
@@ -0,0 +1,377 @@
+#!/usr/bin/env python3
+# Copyright 2021 Canonical Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact: legal@canonical.com
+#
+# To get in touch with the maintainers, please contact:
+# osm-charmers@lists.launchpad.net
+##
+
+import logging
+from ipaddress import ip_network
+from typing import Any, Dict, List
+from urllib.parse import urlparse
+
+logger = logging.getLogger(__name__)
+
+
+def _validate_max_file_size(max_file_size: int, site_url: str) -> bool:
+    """Validate max_file_size.
+
+    Args:
+        max_file_size (int): maximum file size allowed.
+        site_url (str): endpoint url.
+
+    Returns:
+        bool: True if valid, false otherwise.
+    """
+    if not site_url:
+        return True
+
+    parsed = urlparse(site_url)
+
+    if not parsed.scheme.startswith("http"):
+        return True
+
+    if max_file_size is None:
+        return False
+
+    return max_file_size >= 0
+
+
+def _validate_ip_network(network: str) -> bool:
+    """Validate IP network.
+
+    Args:
+        network (str): IP network range.
+
+    Returns:
+        bool: True if valid, false otherwise.
+    """
+    if not network:
+        return True
+
+    try:
+        ip_network(network)
+    except ValueError:
+        return False
+
+    return True
+
+
+def _validate_data(config_data: Dict[str, Any], relation_data: Dict[str, Any]) -> bool:
+    """Validates passed information.
+
+    Args:
+        config_data (Dict[str, Any]): configuration information.
+        relation_data (Dict[str, Any]): relation information
+
+    Raises:
+        ValueError: when config and/or relation data is not valid.
+    """
+    config_validators = {
+        "site_url": lambda value, _: isinstance(value, str)
+        if value is not None
+        else True,
+        "max_file_size": lambda value, values: _validate_max_file_size(
+            value, values.get("site_url")
+        ),
+        "ingress_whitelist_source_range": lambda value, _: _validate_ip_network(value),
+        "tls_secret_name": lambda value, _: isinstance(value, str)
+        if value is not None
+        else True,
+    }
+    relation_validators = {
+        "prometheus_host": lambda value, _: isinstance(value, str) and len(value) > 0,
+        "prometheus_port": lambda value, _: isinstance(value, str)
+        and len(value) > 0
+        and int(value) > 0,
+    }
+    problems = []
+
+    for key, validator in config_validators.items():
+        valid = validator(config_data.get(key), config_data)
+
+        if not valid:
+            problems.append(key)
+
+    for key, validator in relation_validators.items():
+        valid = validator(relation_data.get(key), relation_data)
+
+        if not valid:
+            problems.append(key)
+
+    if len(problems) > 0:
+        raise ValueError("Errors found in: {}".format(", ".join(problems)))
+
+    return True
+
+
+def _make_pod_ports(port: int) -> List[Dict[str, Any]]:
+    """Generate pod ports details.
+
+    Args:
+        port (int): port to expose.
+
+    Returns:
+        List[Dict[str, Any]]: pod port details.
+    """
+    return [{"name": "grafana", "containerPort": port, "protocol": "TCP"}]
+
+
+def _make_pod_envconfig(
+    config: Dict[str, Any], relation_state: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Generate pod environment configuration.
+
+    Args:
+        config (Dict[str, Any]): configuration information.
+        relation_state (Dict[str, Any]): relation state information.
+
+    Returns:
+        Dict[str, Any]: pod environment configuration.
+    """
+    envconfig = {}
+
+    return envconfig
+
+
+def _make_pod_ingress_resources(
+    config: Dict[str, Any], app_name: str, port: int
+) -> List[Dict[str, Any]]:
+    """Generate pod ingress resources.
+
+    Args:
+        config (Dict[str, Any]): configuration information.
+        app_name (str): application name.
+        port (int): port to expose.
+
+    Returns:
+        List[Dict[str, Any]]: pod ingress resources.
+    """
+    site_url = config.get("site_url")
+
+    if not site_url:
+        return
+
+    parsed = urlparse(site_url)
+
+    if not parsed.scheme.startswith("http"):
+        return
+
+    max_file_size = config["max_file_size"]
+    ingress_whitelist_source_range = config["ingress_whitelist_source_range"]
+
+    annotations = {
+        "nginx.ingress.kubernetes.io/proxy-body-size": "{}".format(
+            str(max_file_size) + "m" if max_file_size > 0 else max_file_size
+        ),
+    }
+
+    if ingress_whitelist_source_range:
+        annotations[
+            "nginx.ingress.kubernetes.io/whitelist-source-range"
+        ] = ingress_whitelist_source_range
+
+    ingress_spec_tls = None
+
+    if parsed.scheme == "https":
+        ingress_spec_tls = [{"hosts": [parsed.hostname]}]
+        tls_secret_name = config["tls_secret_name"]
+        if tls_secret_name:
+            ingress_spec_tls[0]["secretName"] = tls_secret_name
+    else:
+        annotations["nginx.ingress.kubernetes.io/ssl-redirect"] = "false"
+
+    ingress = {
+        "name": "{}-ingress".format(app_name),
+        "annotations": annotations,
+        "spec": {
+            "rules": [
+                {
+                    "host": parsed.hostname,
+                    "http": {
+                        "paths": [
+                            {
+                                "path": "/",
+                                "backend": {
+                                    "serviceName": app_name,
+                                    "servicePort": port,
+                                },
+                            }
+                        ]
+                    },
+                }
+            ]
+        },
+    }
+    if ingress_spec_tls:
+        ingress["spec"]["tls"] = ingress_spec_tls
+
+    return [ingress]
+
+
+def _make_pod_files(relation: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """Generating ConfigMap information
+
+    Args:
+        relation (Dict[str, Any]): relation information.
+
+    Returns:
+        List[Dict[str, Any]]: ConfigMap information.
+    """
+    files = [
+        {
+            "name": "dashboards",
+            "mountPath": "/etc/grafana/provisioning/dashboards/",
+            "files": [
+                {
+                    "path": "dashboard-osm.yml",
+                    "content": (
+                        "apiVersion: 1\n"
+                        "providers:\n"
+                        "  - name: 'osm'\n"
+                        "    orgId: 1\n"
+                        "    folder: ''\n"
+                        "    type: file\n"
+                        "    options:\n"
+                        "      path: /etc/grafana/provisioning/dashboards/\n"
+                    ),
+                }
+            ],
+        },
+        {
+            "name": "datasources",
+            "mountPath": "/etc/grafana/provisioning/datasources/",
+            "files": [
+                {
+                    "path": "datasource-prometheus.yml",
+                    "content": (
+                        "datasources:\n"
+                        "  - access: proxy\n"
+                        "    editable: true\n"
+                        "    is_default: true\n"
+                        "    name: osm_prometheus\n"
+                        "    orgId: 1\n"
+                        "    type: prometheus\n"
+                        "    version: 1\n"
+                        "    url: http://{}:{}\n".format(
+                            relation.get("prometheus_host"),
+                            relation.get("prometheus_port"),
+                        )
+                    ),
+                }
+            ],
+        },
+    ]
+
+    return files
+
+
+def _make_readiness_probe(port: int) -> Dict[str, Any]:
+    """Generate readiness probe.
+
+    Args:
+        port (int): service port.
+
+    Returns:
+        Dict[str, Any]: readiness probe.
+    """
+    return {
+        "httpGet": {
+            "path": "/api/health",
+            "port": port,
+        },
+        "initialDelaySeconds": 10,
+        "periodSeconds": 10,
+        "timeoutSeconds": 5,
+        "successThreshold": 1,
+        "failureThreshold": 3,
+    }
+
+
+def _make_liveness_probe(port: int) -> Dict[str, Any]:
+    """Generate liveness probe.
+
+    Args:
+        port (int): service port.
+
+    Returns:
+        Dict[str, Any]: liveness probe.
+    """
+    return {
+        "httpGet": {
+            "path": "/api/health",
+            "port": port,
+        },
+        "initialDelaySeconds": 60,
+        "timeoutSeconds": 30,
+        "failureThreshold": 10,
+    }
+
+
+def make_pod_spec(
+    image_info: Dict[str, str],
+    config: Dict[str, Any],
+    relation_state: Dict[str, Any],
+    app_name: str = "grafana",
+    port: int = 3000,
+) -> Dict[str, Any]:
+    """Generate the pod spec information.
+
+    Args:
+        image_info (Dict[str, str]): Object provided by
+                                     OCIImageResource("image").fetch().
+        config (Dict[str, Any]): Configuration information.
+        relation_state (Dict[str, Any]): Relation state information.
+        app_name (str, optional): Application name. Defaults to "ro".
+        port (int, optional): Port for the container. Defaults to 9090.
+
+    Returns:
+        Dict[str, Any]: Pod spec dictionary for the charm.
+    """
+    if not image_info:
+        return None
+
+    _validate_data(config, relation_state)
+
+    ports = _make_pod_ports(port)
+    env_config = _make_pod_envconfig(config, relation_state)
+    files = _make_pod_files(relation_state)
+    readiness_probe = _make_readiness_probe(port)
+    liveness_probe = _make_liveness_probe(port)
+    ingress_resources = _make_pod_ingress_resources(config, app_name, port)
+
+    return {
+        "version": 3,
+        "containers": [
+            {
+                "name": app_name,
+                "imageDetails": image_info,
+                "imagePullPolicy": "Always",
+                "ports": ports,
+                "envConfig": env_config,
+                "volumeConfig": files,
+                "kubernetes": {
+                    "readinessProbe": readiness_probe,
+                    "livenessProbe": liveness_probe,
+                },
+            }
+        ],
+        "kubernetesResources": {
+            "ingressResources": ingress_resources or [],
+        },
+    }
diff --git a/installers/charm/grafana/tests/__init__.py b/installers/charm/grafana/tests/__init__.py
new file mode 100644
index 0000000..4fd849a
--- /dev/null
+++ b/installers/charm/grafana/tests/__init__.py
@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+# Copyright 2021 Canonical Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact: legal@canonical.com
+#
+# To get in touch with the maintainers, please contact:
+# osm-charmers@lists.launchpad.net
+##
+
+"""Init mocking for unit tests."""
+
+import sys
+import mock
+
+sys.path.append("src")
+
+oci_image = mock.MagicMock()
+sys.modules["oci_image"] = oci_image
diff --git a/installers/charm/grafana/tests/test_charm.py b/installers/charm/grafana/tests/test_charm.py
new file mode 100644
index 0000000..5bbd15b
--- /dev/null
+++ b/installers/charm/grafana/tests/test_charm.py
@@ -0,0 +1,590 @@
+#!/usr/bin/env python3
+# Copyright 2021 Canonical Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact: legal@canonical.com
+#
+# To get in touch with the maintainers, please contact:
+# osm-charmers@lists.launchpad.net
+##
+
+from typing import NoReturn
+import unittest
+
+from ops.model import BlockedStatus
+from ops.testing import Harness
+
+from charm import GrafanaCharm
+
+
+class TestCharm(unittest.TestCase):
+    """Grafana Charm unit tests."""
+
+    def setUp(self) -> NoReturn:
+        """Test setup"""
+        self.harness = Harness(GrafanaCharm)
+        self.harness.set_leader(is_leader=True)
+        self.harness.begin()
+
+    def test_on_start_without_relations(self) -> NoReturn:
+        """Test installation without any relation."""
+        self.harness.charm.on.start.emit()
+
+        # Verifying status
+        self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
+
+        # Verifying status message
+        self.assertGreater(len(self.harness.charm.unit.status.message), 0)
+        self.assertTrue(
+            self.harness.charm.unit.status.message.startswith("Waiting for ")
+        )
+        self.assertIn("prometheus", self.harness.charm.unit.status.message)
+        self.assertTrue(self.harness.charm.unit.status.message.endswith(" relation"))
+
+    def test_on_start_with_relations_without_http(self) -> NoReturn:
+        """Test deployment."""
+        expected_result = {
+            "version": 3,
+            "containers": [
+                {
+                    "name": "grafana",
+                    "imageDetails": self.harness.charm.image.fetch(),
+                    "imagePullPolicy": "Always",
+                    "ports": [
+                        {
+                            "name": "grafana",
+                            "containerPort": 3000,
+                            "protocol": "TCP",
+                        }
+                    ],
+                    "envConfig": {},
+                    "volumeConfig": [
+                        {
+                            "name": "dashboards",
+                            "mountPath": "/etc/grafana/provisioning/dashboards/",
+                            "files": [
+                                {
+                                    "path": "dashboard-osm.yml",
+                                    "content": (
+                                        "apiVersion: 1\n"
+                                        "providers:\n"
+                                        "  - name: 'osm'\n"
+                                        "    orgId: 1\n"
+                                        "    folder: ''\n"
+                                        "    type: file\n"
+                                        "    options:\n"
+                                        "      path: /etc/grafana/provisioning/dashboards/\n"
+                                    ),
+                                },
+                            ],
+                        },
+                        {
+                            "name": "datasources",
+                            "mountPath": "/etc/grafana/provisioning/datasources/",
+                            "files": [
+                                {
+                                    "path": "datasource-prometheus.yml",
+                                    "content": (
+                                        "datasources:\n"
+                                        "  - access: proxy\n"
+                                        "    editable: true\n"
+                                        "    is_default: true\n"
+                                        "    name: osm_prometheus\n"
+                                        "    orgId: 1\n"
+                                        "    type: prometheus\n"
+                                        "    version: 1\n"
+                                        "    url: http://prometheus:9090\n"
+                                    ),
+                                },
+                            ],
+                        },
+                    ],
+                    "kubernetes": {
+                        "readinessProbe": {
+                            "httpGet": {
+                                "path": "/api/health",
+                                "port": 3000,
+                            },
+                            "initialDelaySeconds": 10,
+                            "periodSeconds": 10,
+                            "timeoutSeconds": 5,
+                            "successThreshold": 1,
+                            "failureThreshold": 3,
+                        },
+                        "livenessProbe": {
+                            "httpGet": {
+                                "path": "/api/health",
+                                "port": 3000,
+                            },
+                            "initialDelaySeconds": 60,
+                            "timeoutSeconds": 30,
+                            "failureThreshold": 10,
+                        },
+                    },
+                },
+            ],
+            "kubernetesResources": {"ingressResources": []},
+        }
+
+        self.harness.charm.on.start.emit()
+
+        # Initializing the prometheus relation
+        relation_id = self.harness.add_relation("prometheus", "prometheus")
+        self.harness.add_relation_unit(relation_id, "prometheus/0")
+        self.harness.update_relation_data(
+            relation_id,
+            "prometheus/0",
+            {
+                "host": "prometheus",
+                "port": "9090",
+            },
+        )
+
+        # Verifying status
+        self.assertNotIsInstance(self.harness.charm.unit.status, BlockedStatus)
+
+        pod_spec, _ = self.harness.get_pod_spec()
+
+        self.assertDictEqual(expected_result, pod_spec)
+
+    def test_ingress_resources_with_http(self) -> NoReturn:
+        """Test ingress resources with HTTP."""
+        expected_result = {
+            "version": 3,
+            "containers": [
+                {
+                    "name": "grafana",
+                    "imageDetails": self.harness.charm.image.fetch(),
+                    "imagePullPolicy": "Always",
+                    "ports": [
+                        {
+                            "name": "grafana",
+                            "containerPort": 3000,
+                            "protocol": "TCP",
+                        }
+                    ],
+                    "envConfig": {},
+                    "volumeConfig": [
+                        {
+                            "name": "dashboards",
+                            "mountPath": "/etc/grafana/provisioning/dashboards/",
+                            "files": [
+                                {
+                                    "path": "dashboard-osm.yml",
+                                    "content": (
+                                        "apiVersion: 1\n"
+                                        "providers:\n"
+                                        "  - name: 'osm'\n"
+                                        "    orgId: 1\n"
+                                        "    folder: ''\n"
+                                        "    type: file\n"
+                                        "    options:\n"
+                                        "      path: /etc/grafana/provisioning/dashboards/\n"
+                                    ),
+                                },
+                            ],
+                        },
+                        {
+                            "name": "datasources",
+                            "mountPath": "/etc/grafana/provisioning/datasources/",
+                            "files": [
+                                {
+                                    "path": "datasource-prometheus.yml",
+                                    "content": (
+                                        "datasources:\n"
+                                        "  - access: proxy\n"
+                                        "    editable: true\n"
+                                        "    is_default: true\n"
+                                        "    name: osm_prometheus\n"
+                                        "    orgId: 1\n"
+                                        "    type: prometheus\n"
+                                        "    version: 1\n"
+                                        "    url: http://prometheus:9090\n"
+                                    ),
+                                },
+                            ],
+                        },
+                    ],
+                    "kubernetes": {
+                        "readinessProbe": {
+                            "httpGet": {
+                                "path": "/api/health",
+                                "port": 3000,
+                            },
+                            "initialDelaySeconds": 10,
+                            "periodSeconds": 10,
+                            "timeoutSeconds": 5,
+                            "successThreshold": 1,
+                            "failureThreshold": 3,
+                        },
+                        "livenessProbe": {
+                            "httpGet": {
+                                "path": "/api/health",
+                                "port": 3000,
+                            },
+                            "initialDelaySeconds": 60,
+                            "timeoutSeconds": 30,
+                            "failureThreshold": 10,
+                        },
+                    },
+                },
+            ],
+            "kubernetesResources": {
+                "ingressResources": [
+                    {
+                        "name": "grafana-ingress",
+                        "annotations": {
+                            "nginx.ingress.kubernetes.io/proxy-body-size": "0",
+                            "nginx.ingress.kubernetes.io/ssl-redirect": "false",
+                        },
+                        "spec": {
+                            "rules": [
+                                {
+                                    "host": "grafana",
+                                    "http": {
+                                        "paths": [
+                                            {
+                                                "path": "/",
+                                                "backend": {
+                                                    "serviceName": "grafana",
+                                                    "servicePort": 3000,
+                                                },
+                                            }
+                                        ]
+                                    },
+                                }
+                            ]
+                        },
+                    }
+                ],
+            },
+        }
+
+        self.harness.charm.on.start.emit()
+
+        # Initializing the prometheus relation
+        relation_id = self.harness.add_relation("prometheus", "prometheus")
+        self.harness.add_relation_unit(relation_id, "prometheus/0")
+        self.harness.update_relation_data(
+            relation_id,
+            "prometheus/0",
+            {
+                "host": "prometheus",
+                "port": "9090",
+            },
+        )
+
+        self.harness.update_config({"site_url": "http://grafana"})
+
+        pod_spec, _ = self.harness.get_pod_spec()
+
+        self.assertDictEqual(expected_result, pod_spec)
+
+    def test_ingress_resources_with_https(self) -> NoReturn:
+        """Test ingress resources with HTTPS."""
+        expected_result = {
+            "version": 3,
+            "containers": [
+                {
+                    "name": "grafana",
+                    "imageDetails": self.harness.charm.image.fetch(),
+                    "imagePullPolicy": "Always",
+                    "ports": [
+                        {
+                            "name": "grafana",
+                            "containerPort": 3000,
+                            "protocol": "TCP",
+                        }
+                    ],
+                    "envConfig": {},
+                    "volumeConfig": [
+                        {
+                            "name": "dashboards",
+                            "mountPath": "/etc/grafana/provisioning/dashboards/",
+                            "files": [
+                                {
+                                    "path": "dashboard-osm.yml",
+                                    "content": (
+                                        "apiVersion: 1\n"
+                                        "providers:\n"
+                                        "  - name: 'osm'\n"
+                                        "    orgId: 1\n"
+                                        "    folder: ''\n"
+                                        "    type: file\n"
+                                        "    options:\n"
+                                        "      path: /etc/grafana/provisioning/dashboards/\n"
+                                    ),
+                                },
+                            ],
+                        },
+                        {
+                            "name": "datasources",
+                            "mountPath": "/etc/grafana/provisioning/datasources/",
+                            "files": [
+                                {
+                                    "path": "datasource-prometheus.yml",
+                                    "content": (
+                                        "datasources:\n"
+                                        "  - access: proxy\n"
+                                        "    editable: true\n"
+                                        "    is_default: true\n"
+                                        "    name: osm_prometheus\n"
+                                        "    orgId: 1\n"
+                                        "    type: prometheus\n"
+                                        "    version: 1\n"
+                                        "    url: http://prometheus:9090\n"
+                                    ),
+                                },
+                            ],
+                        },
+                    ],
+                    "kubernetes": {
+                        "readinessProbe": {
+                            "httpGet": {
+                                "path": "/api/health",
+                                "port": 3000,
+                            },
+                            "initialDelaySeconds": 10,
+                            "periodSeconds": 10,
+                            "timeoutSeconds": 5,
+                            "successThreshold": 1,
+                            "failureThreshold": 3,
+                        },
+                        "livenessProbe": {
+                            "httpGet": {
+                                "path": "/api/health",
+                                "port": 3000,
+                            },
+                            "initialDelaySeconds": 60,
+                            "timeoutSeconds": 30,
+                            "failureThreshold": 10,
+                        },
+                    },
+                },
+            ],
+            "kubernetesResources": {
+                "ingressResources": [
+                    {
+                        "name": "grafana-ingress",
+                        "annotations": {
+                            "nginx.ingress.kubernetes.io/proxy-body-size": "0",
+                        },
+                        "spec": {
+                            "rules": [
+                                {
+                                    "host": "grafana",
+                                    "http": {
+                                        "paths": [
+                                            {
+                                                "path": "/",
+                                                "backend": {
+                                                    "serviceName": "grafana",
+                                                    "servicePort": 3000,
+                                                },
+                                            }
+                                        ]
+                                    },
+                                }
+                            ],
+                            "tls": [{"hosts": ["grafana"], "secretName": "grafana"}],
+                        },
+                    }
+                ],
+            },
+        }
+
+        self.harness.charm.on.start.emit()
+
+        # Initializing the prometheus relation
+        relation_id = self.harness.add_relation("prometheus", "prometheus")
+        self.harness.add_relation_unit(relation_id, "prometheus/0")
+        self.harness.update_relation_data(
+            relation_id,
+            "prometheus/0",
+            {
+                "host": "prometheus",
+                "port": "9090",
+            },
+        )
+
+        self.harness.update_config(
+            {"site_url": "https://grafana", "tls_secret_name": "grafana"}
+        )
+
+        pod_spec, _ = self.harness.get_pod_spec()
+
+        self.assertDictEqual(expected_result, pod_spec)
+
+    def test_ingress_resources_with_https_and_ingress_whitelist(self) -> NoReturn:
+        """Test ingress resources with HTTPS and ingress whitelist."""
+        expected_result = {
+            "version": 3,
+            "containers": [
+                {
+                    "name": "grafana",
+                    "imageDetails": self.harness.charm.image.fetch(),
+                    "imagePullPolicy": "Always",
+                    "ports": [
+                        {
+                            "name": "grafana",
+                            "containerPort": 3000,
+                            "protocol": "TCP",
+                        }
+                    ],
+                    "envConfig": {},
+                    "volumeConfig": [
+                        {
+                            "name": "dashboards",
+                            "mountPath": "/etc/grafana/provisioning/dashboards/",
+                            "files": [
+                                {
+                                    "path": "dashboard-osm.yml",
+                                    "content": (
+                                        "apiVersion: 1\n"
+                                        "providers:\n"
+                                        "  - name: 'osm'\n"
+                                        "    orgId: 1\n"
+                                        "    folder: ''\n"
+                                        "    type: file\n"
+                                        "    options:\n"
+                                        "      path: /etc/grafana/provisioning/dashboards/\n"
+                                    ),
+                                },
+                            ],
+                        },
+                        {
+                            "name": "datasources",
+                            "mountPath": "/etc/grafana/provisioning/datasources/",
+                            "files": [
+                                {
+                                    "path": "datasource-prometheus.yml",
+                                    "content": (
+                                        "datasources:\n"
+                                        "  - access: proxy\n"
+                                        "    editable: true\n"
+                                        "    is_default: true\n"
+                                        "    name: osm_prometheus\n"
+                                        "    orgId: 1\n"
+                                        "    type: prometheus\n"
+                                        "    version: 1\n"
+                                        "    url: http://prometheus:9090\n"
+                                    ),
+                                },
+                            ],
+                        },
+                    ],
+                    "kubernetes": {
+                        "readinessProbe": {
+                            "httpGet": {
+                                "path": "/api/health",
+                                "port": 3000,
+                            },
+                            "initialDelaySeconds": 10,
+                            "periodSeconds": 10,
+                            "timeoutSeconds": 5,
+                            "successThreshold": 1,
+                            "failureThreshold": 3,
+                        },
+                        "livenessProbe": {
+                            "httpGet": {
+                                "path": "/api/health",
+                                "port": 3000,
+                            },
+                            "initialDelaySeconds": 60,
+                            "timeoutSeconds": 30,
+                            "failureThreshold": 10,
+                        },
+                    },
+                },
+            ],
+            "kubernetesResources": {
+                "ingressResources": [
+                    {
+                        "name": "grafana-ingress",
+                        "annotations": {
+                            "nginx.ingress.kubernetes.io/proxy-body-size": "0",
+                            "nginx.ingress.kubernetes.io/whitelist-source-range": "0.0.0.0/0",
+                        },
+                        "spec": {
+                            "rules": [
+                                {
+                                    "host": "grafana",
+                                    "http": {
+                                        "paths": [
+                                            {
+                                                "path": "/",
+                                                "backend": {
+                                                    "serviceName": "grafana",
+                                                    "servicePort": 3000,
+                                                },
+                                            }
+                                        ]
+                                    },
+                                }
+                            ],
+                            "tls": [{"hosts": ["grafana"], "secretName": "grafana"}],
+                        },
+                    }
+                ],
+            },
+        }
+
+        self.harness.charm.on.start.emit()
+
+        # Initializing the prometheus relation
+        relation_id = self.harness.add_relation("prometheus", "prometheus")
+        self.harness.add_relation_unit(relation_id, "prometheus/0")
+        self.harness.update_relation_data(
+            relation_id,
+            "prometheus/0",
+            {
+                "host": "prometheus",
+                "port": "9090",
+            },
+        )
+
+        self.harness.update_config(
+            {
+                "site_url": "https://grafana",
+                "tls_secret_name": "grafana",
+                "ingress_whitelist_source_range": "0.0.0.0/0",
+            }
+        )
+
+        pod_spec, _ = self.harness.get_pod_spec()
+
+        self.assertDictEqual(expected_result, pod_spec)
+
+    def test_on_prometheus_unit_relation_changed(self) -> NoReturn:
+        """Test to see if prometheus relation is updated."""
+        self.harness.charm.on.start.emit()
+
+        relation_id = self.harness.add_relation("prometheus", "prometheus")
+        self.harness.add_relation_unit(relation_id, "prometheus/0")
+        self.harness.update_relation_data(
+            relation_id,
+            "prometheus/0",
+            {
+                "host": "prometheus",
+                "port": "9090",
+            },
+        )
+
+        # Verifying status
+        self.assertNotIsInstance(self.harness.charm.unit.status, BlockedStatus)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/installers/charm/grafana/tests/test_pod_spec.py b/installers/charm/grafana/tests/test_pod_spec.py
new file mode 100644
index 0000000..842769c
--- /dev/null
+++ b/installers/charm/grafana/tests/test_pod_spec.py
@@ -0,0 +1,636 @@
+#!/usr/bin/env python3
+# Copyright 2021 Canonical Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact: legal@canonical.com
+#
+# To get in touch with the maintainers, please contact:
+# osm-charmers@lists.launchpad.net
+##
+
+from typing import NoReturn
+import unittest
+
+import pod_spec
+
+
+class TestPodSpec(unittest.TestCase):
+    """Pod spec unit tests."""
+
+    def test_make_pod_ports(self) -> NoReturn:
+        """Testing make pod ports."""
+        port = 3000
+
+        expected_result = [
+            {
+                "name": "grafana",
+                "containerPort": port,
+                "protocol": "TCP",
+            }
+        ]
+
+        pod_ports = pod_spec._make_pod_ports(port)
+
+        self.assertListEqual(expected_result, pod_ports)
+
+    def test_make_pod_envconfig(self) -> NoReturn:
+        """Teting make pod envconfig."""
+        config = {}
+        relation_state = {
+            "prometheus_host": "prometheus",
+            "prometheus_port": "9090",
+        }
+
+        expected_result = {}
+
+        pod_envconfig = pod_spec._make_pod_envconfig(config, relation_state)
+
+        self.assertDictEqual(expected_result, pod_envconfig)
+
+    def test_make_pod_ingress_resources_without_site_url(self) -> NoReturn:
+        """Testing make pod ingress resources without site_url."""
+        config = {"site_url": ""}
+        app_name = "grafana"
+        port = 3000
+
+        pod_ingress_resources = pod_spec._make_pod_ingress_resources(
+            config, app_name, port
+        )
+
+        self.assertIsNone(pod_ingress_resources)
+
+    def test_make_pod_ingress_resources(self) -> NoReturn:
+        """Testing make pod ingress resources."""
+        config = {
+            "site_url": "http://grafana",
+            "max_file_size": 0,
+            "ingress_whitelist_source_range": "",
+        }
+        app_name = "grafana"
+        port = 3000
+
+        expected_result = [
+            {
+                "name": f"{app_name}-ingress",
+                "annotations": {
+                    "nginx.ingress.kubernetes.io/proxy-body-size": f"{config['max_file_size']}",
+                    "nginx.ingress.kubernetes.io/ssl-redirect": "false",
+                },
+                "spec": {
+                    "rules": [
+                        {
+                            "host": app_name,
+                            "http": {
+                                "paths": [
+                                    {
+                                        "path": "/",
+                                        "backend": {
+                                            "serviceName": app_name,
+                                            "servicePort": port,
+                                        },
+                                    }
+                                ]
+                            },
+                        }
+                    ]
+                },
+            }
+        ]
+
+        pod_ingress_resources = pod_spec._make_pod_ingress_resources(
+            config, app_name, port
+        )
+
+        self.assertListEqual(expected_result, pod_ingress_resources)
+
+    def test_make_pod_ingress_resources_with_whitelist_source_range(self) -> NoReturn:
+        """Testing make pod ingress resources with whitelist_source_range."""
+        config = {
+            "site_url": "http://grafana",
+            "max_file_size": 0,
+            "ingress_whitelist_source_range": "0.0.0.0/0",
+        }
+        app_name = "grafana"
+        port = 3000
+
+        expected_result = [
+            {
+                "name": f"{app_name}-ingress",
+                "annotations": {
+                    "nginx.ingress.kubernetes.io/proxy-body-size": f"{config['max_file_size']}",
+                    "nginx.ingress.kubernetes.io/ssl-redirect": "false",
+                    "nginx.ingress.kubernetes.io/whitelist-source-range": config[
+                        "ingress_whitelist_source_range"
+                    ],
+                },
+                "spec": {
+                    "rules": [
+                        {
+                            "host": app_name,
+                            "http": {
+                                "paths": [
+                                    {
+                                        "path": "/",
+                                        "backend": {
+                                            "serviceName": app_name,
+                                            "servicePort": port,
+                                        },
+                                    }
+                                ]
+                            },
+                        }
+                    ]
+                },
+            }
+        ]
+
+        pod_ingress_resources = pod_spec._make_pod_ingress_resources(
+            config, app_name, port
+        )
+
+        self.assertListEqual(expected_result, pod_ingress_resources)
+
+    def test_make_pod_ingress_resources_with_https(self) -> NoReturn:
+        """Testing make pod ingress resources with HTTPs."""
+        config = {
+            "site_url": "https://grafana",
+            "max_file_size": 0,
+            "ingress_whitelist_source_range": "",
+            "tls_secret_name": "",
+        }
+        app_name = "grafana"
+        port = 3000
+
+        expected_result = [
+            {
+                "name": f"{app_name}-ingress",
+                "annotations": {
+                    "nginx.ingress.kubernetes.io/proxy-body-size": f"{config['max_file_size']}",
+                },
+                "spec": {
+                    "rules": [
+                        {
+                            "host": app_name,
+                            "http": {
+                                "paths": [
+                                    {
+                                        "path": "/",
+                                        "backend": {
+                                            "serviceName": app_name,
+                                            "servicePort": port,
+                                        },
+                                    }
+                                ]
+                            },
+                        }
+                    ],
+                    "tls": [{"hosts": [app_name]}],
+                },
+            }
+        ]
+
+        pod_ingress_resources = pod_spec._make_pod_ingress_resources(
+            config, app_name, port
+        )
+
+        self.assertListEqual(expected_result, pod_ingress_resources)
+
+    def test_make_pod_ingress_resources_with_https_tls_secret_name(self) -> NoReturn:
+        """Testing make pod ingress resources with HTTPs and TLS secret name."""
+        config = {
+            "site_url": "https://grafana",
+            "max_file_size": 0,
+            "ingress_whitelist_source_range": "",
+            "tls_secret_name": "secret_name",
+        }
+        app_name = "grafana"
+        port = 3000
+
+        expected_result = [
+            {
+                "name": f"{app_name}-ingress",
+                "annotations": {
+                    "nginx.ingress.kubernetes.io/proxy-body-size": f"{config['max_file_size']}",
+                },
+                "spec": {
+                    "rules": [
+                        {
+                            "host": app_name,
+                            "http": {
+                                "paths": [
+                                    {
+                                        "path": "/",
+                                        "backend": {
+                                            "serviceName": app_name,
+                                            "servicePort": port,
+                                        },
+                                    }
+                                ]
+                            },
+                        }
+                    ],
+                    "tls": [
+                        {"hosts": [app_name], "secretName": config["tls_secret_name"]}
+                    ],
+                },
+            }
+        ]
+
+        pod_ingress_resources = pod_spec._make_pod_ingress_resources(
+            config, app_name, port
+        )
+
+        self.assertListEqual(expected_result, pod_ingress_resources)
+
+    def test_make_pod_files(self) -> NoReturn:
+        """Testing make pod files."""
+        relation_state = {
+            "prometheus_host": "prometheus",
+            "prometheus_port": "9090",
+        }
+
+        expected_result = [
+            {
+                "name": "dashboards",
+                "mountPath": "/etc/grafana/provisioning/dashboards/",
+                "files": [
+                    {
+                        "path": "dashboard-osm.yml",
+                        "content": (
+                            "apiVersion: 1\n"
+                            "providers:\n"
+                            "  - name: 'osm'\n"
+                            "    orgId: 1\n"
+                            "    folder: ''\n"
+                            "    type: file\n"
+                            "    options:\n"
+                            "      path: /etc/grafana/provisioning/dashboards/\n"
+                        ),
+                    }
+                ],
+            },
+            {
+                "name": "datasources",
+                "mountPath": "/etc/grafana/provisioning/datasources/",
+                "files": [
+                    {
+                        "path": "datasource-prometheus.yml",
+                        "content": (
+                            "datasources:\n"
+                            "  - access: proxy\n"
+                            "    editable: true\n"
+                            "    is_default: true\n"
+                            "    name: osm_prometheus\n"
+                            "    orgId: 1\n"
+                            "    type: prometheus\n"
+                            "    version: 1\n"
+                            "    url: http://{}:{}\n".format(
+                                relation_state.get("prometheus_host"),
+                                relation_state.get("prometheus_port"),
+                            )
+                        ),
+                    }
+                ],
+            },
+        ]
+
+        pod_envconfig = pod_spec._make_pod_files(relation_state)
+
+        self.assertListEqual(expected_result, pod_envconfig)
+
+    def test_make_readiness_probe(self) -> NoReturn:
+        """Testing make readiness probe."""
+        port = 3000
+
+        expected_result = {
+            "httpGet": {
+                "path": "/api/health",
+                "port": port,
+            },
+            "initialDelaySeconds": 10,
+            "periodSeconds": 10,
+            "timeoutSeconds": 5,
+            "successThreshold": 1,
+            "failureThreshold": 3,
+        }
+
+        readiness_probe = pod_spec._make_readiness_probe(port)
+
+        self.assertDictEqual(expected_result, readiness_probe)
+
+    def test_make_liveness_probe(self) -> NoReturn:
+        """Testing make liveness probe."""
+        port = 3000
+
+        expected_result = {
+            "httpGet": {
+                "path": "/api/health",
+                "port": port,
+            },
+            "initialDelaySeconds": 60,
+            "timeoutSeconds": 30,
+            "failureThreshold": 10,
+        }
+
+        liveness_probe = pod_spec._make_liveness_probe(port)
+
+        self.assertDictEqual(expected_result, liveness_probe)
+
+    def test_make_pod_spec(self) -> NoReturn:
+        """Testing make pod spec."""
+        image_info = {"upstream-source": "ubuntu/grafana:latest"}
+        config = {
+            "site_url": "",
+        }
+        relation_state = {
+            "prometheus_host": "prometheus",
+            "prometheus_port": "9090",
+        }
+        app_name = "grafana"
+        port = 3000
+
+        expected_result = {
+            "version": 3,
+            "containers": [
+                {
+                    "name": app_name,
+                    "imageDetails": image_info,
+                    "imagePullPolicy": "Always",
+                    "ports": [
+                        {
+                            "name": app_name,
+                            "containerPort": port,
+                            "protocol": "TCP",
+                        }
+                    ],
+                    "envConfig": {},
+                    "volumeConfig": [
+                        {
+                            "name": "dashboards",
+                            "mountPath": "/etc/grafana/provisioning/dashboards/",
+                            "files": [
+                                {
+                                    "path": "dashboard-osm.yml",
+                                    "content": (
+                                        "apiVersion: 1\n"
+                                        "providers:\n"
+                                        "  - name: 'osm'\n"
+                                        "    orgId: 1\n"
+                                        "    folder: ''\n"
+                                        "    type: file\n"
+                                        "    options:\n"
+                                        "      path: /etc/grafana/provisioning/dashboards/\n"
+                                    ),
+                                }
+                            ],
+                        },
+                        {
+                            "name": "datasources",
+                            "mountPath": "/etc/grafana/provisioning/datasources/",
+                            "files": [
+                                {
+                                    "path": "datasource-prometheus.yml",
+                                    "content": (
+                                        "datasources:\n"
+                                        "  - access: proxy\n"
+                                        "    editable: true\n"
+                                        "    is_default: true\n"
+                                        "    name: osm_prometheus\n"
+                                        "    orgId: 1\n"
+                                        "    type: prometheus\n"
+                                        "    version: 1\n"
+                                        "    url: http://{}:{}\n".format(
+                                            relation_state.get("prometheus_host"),
+                                            relation_state.get("prometheus_port"),
+                                        )
+                                    ),
+                                }
+                            ],
+                        },
+                    ],
+                    "kubernetes": {
+                        "readinessProbe": {
+                            "httpGet": {
+                                "path": "/api/health",
+                                "port": port,
+                            },
+                            "initialDelaySeconds": 10,
+                            "periodSeconds": 10,
+                            "timeoutSeconds": 5,
+                            "successThreshold": 1,
+                            "failureThreshold": 3,
+                        },
+                        "livenessProbe": {
+                            "httpGet": {
+                                "path": "/api/health",
+                                "port": port,
+                            },
+                            "initialDelaySeconds": 60,
+                            "timeoutSeconds": 30,
+                            "failureThreshold": 10,
+                        },
+                    },
+                }
+            ],
+            "kubernetesResources": {"ingressResources": []},
+        }
+
+        spec = pod_spec.make_pod_spec(
+            image_info, config, relation_state, app_name, port
+        )
+
+        self.assertDictEqual(expected_result, spec)
+
+    def test_make_pod_spec_with_ingress(self) -> NoReturn:
+        """Testing make pod spec."""
+        image_info = {"upstream-source": "ubuntu/grafana:latest"}
+        config = {
+            "site_url": "https://grafana",
+            "tls_secret_name": "grafana",
+            "max_file_size": 0,
+            "ingress_whitelist_source_range": "0.0.0.0/0",
+        }
+        relation_state = {
+            "prometheus_host": "prometheus",
+            "prometheus_port": "9090",
+        }
+        app_name = "grafana"
+        port = 3000
+
+        expected_result = {
+            "version": 3,
+            "containers": [
+                {
+                    "name": app_name,
+                    "imageDetails": image_info,
+                    "imagePullPolicy": "Always",
+                    "ports": [
+                        {
+                            "name": app_name,
+                            "containerPort": port,
+                            "protocol": "TCP",
+                        }
+                    ],
+                    "envConfig": {},
+                    "volumeConfig": [
+                        {
+                            "name": "dashboards",
+                            "mountPath": "/etc/grafana/provisioning/dashboards/",
+                            "files": [
+                                {
+                                    "path": "dashboard-osm.yml",
+                                    "content": (
+                                        "apiVersion: 1\n"
+                                        "providers:\n"
+                                        "  - name: 'osm'\n"
+                                        "    orgId: 1\n"
+                                        "    folder: ''\n"
+                                        "    type: file\n"
+                                        "    options:\n"
+                                        "      path: /etc/grafana/provisioning/dashboards/\n"
+                                    ),
+                                }
+                            ],
+                        },
+                        {
+                            "name": "datasources",
+                            "mountPath": "/etc/grafana/provisioning/datasources/",
+                            "files": [
+                                {
+                                    "path": "datasource-prometheus.yml",
+                                    "content": (
+                                        "datasources:\n"
+                                        "  - access: proxy\n"
+                                        "    editable: true\n"
+                                        "    is_default: true\n"
+                                        "    name: osm_prometheus\n"
+                                        "    orgId: 1\n"
+                                        "    type: prometheus\n"
+                                        "    version: 1\n"
+                                        "    url: http://{}:{}\n".format(
+                                            relation_state.get("prometheus_host"),
+                                            relation_state.get("prometheus_port"),
+                                        )
+                                    ),
+                                }
+                            ],
+                        },
+                    ],
+                    "kubernetes": {
+                        "readinessProbe": {
+                            "httpGet": {
+                                "path": "/api/health",
+                                "port": port,
+                            },
+                            "initialDelaySeconds": 10,
+                            "periodSeconds": 10,
+                            "timeoutSeconds": 5,
+                            "successThreshold": 1,
+                            "failureThreshold": 3,
+                        },
+                        "livenessProbe": {
+                            "httpGet": {
+                                "path": "/api/health",
+                                "port": port,
+                            },
+                            "initialDelaySeconds": 60,
+                            "timeoutSeconds": 30,
+                            "failureThreshold": 10,
+                        },
+                    },
+                }
+            ],
+            "kubernetesResources": {
+                "ingressResources": [
+                    {
+                        "name": "{}-ingress".format(app_name),
+                        "annotations": {
+                            "nginx.ingress.kubernetes.io/proxy-body-size": str(
+                                config.get("max_file_size")
+                            ),
+                            "nginx.ingress.kubernetes.io/whitelist-source-range": config.get(
+                                "ingress_whitelist_source_range"
+                            ),
+                        },
+                        "spec": {
+                            "rules": [
+                                {
+                                    "host": app_name,
+                                    "http": {
+                                        "paths": [
+                                            {
+                                                "path": "/",
+                                                "backend": {
+                                                    "serviceName": app_name,
+                                                    "servicePort": port,
+                                                },
+                                            }
+                                        ]
+                                    },
+                                }
+                            ],
+                            "tls": [
+                                {
+                                    "hosts": [app_name],
+                                    "secretName": config.get("tls_secret_name"),
+                                }
+                            ],
+                        },
+                    }
+                ],
+            },
+        }
+
+        spec = pod_spec.make_pod_spec(
+            image_info, config, relation_state, app_name, port
+        )
+
+        self.assertDictEqual(expected_result, spec)
+
+    def test_make_pod_spec_without_image_info(self) -> NoReturn:
+        """Testing make pod spec without image_info."""
+        image_info = None
+        config = {
+            "site_url": "",
+        }
+        relation_state = {
+            "prometheus_host": "prometheus",
+            "prometheus_port": "9090",
+        }
+        app_name = "grafana"
+        port = 3000
+
+        spec = pod_spec.make_pod_spec(
+            image_info, config, relation_state, app_name, port
+        )
+
+        self.assertIsNone(spec)
+
+    def test_make_pod_spec_without_relation_state(self) -> NoReturn:
+        """Testing make pod spec without relation_state."""
+        image_info = {"upstream-source": "ubuntu/grafana:latest"}
+        config = {
+            "site_url": "",
+        }
+        relation_state = {}
+        app_name = "grafana"
+        port = 3000
+
+        with self.assertRaises(ValueError):
+            pod_spec.make_pod_spec(image_info, config, relation_state, app_name, port)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/installers/charm/grafana/tox.ini b/installers/charm/grafana/tox.ini
new file mode 100644
index 0000000..12a1f85
--- /dev/null
+++ b/installers/charm/grafana/tox.ini
@@ -0,0 +1,81 @@
+# Copyright 2021 Canonical Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact: legal@canonical.com
+#
+# To get in touch with the maintainers, please contact:
+# osm-charmers@lists.launchpad.net
+##
+
+[tox]
+skipsdist = True
+envlist = unit, lint
+sitepackages = False
+skip_missing_interpreters = False
+
+[testenv]
+basepython = python3
+setenv =
+  PYTHONHASHSEED=0
+  PYTHONPATH = {toxinidir}/src
+  CHARM_NAME = grafana
+
+[testenv:build]
+passenv=HTTP_PROXY HTTPS_PROXY NO_PROXY
+whitelist_externals =
+  charmcraft
+  rm
+  unzip
+commands =
+  rm -rf release grafana.charm
+  charmcraft build
+  unzip grafana.charm -d release
+
+[testenv:unit]
+commands =
+  coverage erase
+  stestr run --slowest --test-path=./tests --top-dir=./
+  coverage combine
+  coverage html -d cover
+  coverage xml -o cover/coverage.xml
+  coverage report
+deps =
+  coverage
+  stestr
+  mock
+  ops
+setenv =
+  {[testenv]setenv}
+  PYTHON=coverage run
+
+[testenv:lint]
+deps =
+  black
+  yamllint
+  flake8
+commands =
+  black --check --diff . --exclude "build/|.tox/|mod/|lib/"
+  yamllint .
+  flake8 . --max-line-length=100 --ignore="E501,W503,W504,F722" --exclude "build/ .tox/ mod/ lib/"
+
+[coverage:run]
+branch = True
+concurrency = multiprocessing
+parallel = True
+source =
+  .
+omit =
+  .tox/*
+  tests/*