Merge ~sajoupa/charm-k8s-telegraf:sidecar into charm-k8s-telegraf:master

[Laurent Sesquès]

Switch to the sidecar framework

316e11b... by Laurent Sesquès on 2021-05-11

Dockerfile: use a more suitable name for the CMD

2396cf7... by Laurent Sesquès on 2021-05-11

import the nginx-ingress-integrator lib

f3c7b62... by Laurent Sesquès on 2021-05-11

config.yaml: restrict open_port to just 1 port number, and restrict to tcp

604d966... by Laurent Sesquès on 2021-05-11

rename the charm to telegraf-k8s, add display-name

df32e90... by Laurent Sesquès on 2021-05-11

charm.py: various fixes, and updates coming from previous commits

9d2bf26... by Laurent Sesquès on 2021-05-11

update tests following conversion to the sidecar framework

efd9949... by Laurent Sesquès on 2021-05-11

Makefile: perform a build before running unittests

4315d13... by Laurent Sesquès on 2021-05-12

Add a relation with postgresql-k8s

4f8a99a... by Laurent Sesquès on 2021-05-12

make sure _on_config_changed is called with a PG relation is changed

5e88ed7... by Laurent Sesquès on 2021-05-12

add jinja2 to the unit tests requirements

251cdee... by Laurent Sesquès on 2021-05-14

remove image_* configs (now using a resource), install ca-certificates in the image, update README, add docs: link to metadata.yaml

acb12a9... by Laurent Sesquès on 2021-05-14

README: fix markup

c11cdd5... by Laurent Sesquès on 2021-05-14

README: fix wrong copy/paste. config.yaml: remove obsolete comment for open_port and lp:1876129.

7560863... by Laurent Sesquès on 2021-05-14

Add a get-prometheus-metrics action

8e657b6... by Laurent Sesquès on 2021-05-17

small README improvements

468043c... by Laurent Sesquès on 2021-05-18

README: add a section for the get-prometheus-metrics action

Unmerged commits

468043c... by Laurent Sesquès on 2021-05-18

README: add a section for the get-prometheus-metrics action

8e657b6... by Laurent Sesquès on 2021-05-17

small README improvements

7560863... by Laurent Sesquès on 2021-05-14

Add a get-prometheus-metrics action

c11cdd5... by Laurent Sesquès on 2021-05-14

README: fix wrong copy/paste. config.yaml: remove obsolete comment for open_port and lp:1876129.

acb12a9... by Laurent Sesquès on 2021-05-14

README: fix markup

251cdee... by Laurent Sesquès on 2021-05-14

remove image_* configs (now using a resource), install ca-certificates in the image, update README, add docs: link to metadata.yaml

5e88ed7... by Laurent Sesquès on 2021-05-12

add jinja2 to the unit tests requirements

4f8a99a... by Laurent Sesquès on 2021-05-12

make sure _on_config_changed is called with a PG relation is changed

4315d13... by Laurent Sesquès on 2021-05-12

Add a relation with postgresql-k8s

efd9949... by Laurent Sesquès on 2021-05-11

Makefile: perform a build before running unittests

diff --git a/Makefile b/Makefile
index 7a71e0f..e2df6b8 100644
--- a/Makefile
+++ b/Makefile
@@ -16,7 +16,7 @@ lint: blacken
 
 # We actually use the build directory created by charmcraft,
 # but the .charm file makes a much more convenient sentinel.
-unittests:
+unittests: build
 	@tox -e unit
 
 build:
@@ -24,7 +24,8 @@ build:
 	@-git rev-parse HEAD > ./repo-info
 	@cd ${CHARM_BUILD_DIR} && TERM=linux charmcraft build -f ${PROJECTPATH}
 
-test: lint unittests functional
+# TODO: fix functional tests, broken with juju 2.9.0 + zaza 94abaf1 + microk8s v1.20.6
+test: lint unittests #functional
 	@echo "Tests completed for charm ${CHARM_NAME}."
 
 functional: build
@@ -40,7 +41,6 @@ clean:
 image-build:
 	@echo "Building the image."
 	@docker build \
-		--no-cache=true \
 		--build-arg VERSION_TO_BUILD=$(VERSION_TO_BUILD) \
 		-t telegraf:$(VERSION_TO_BUILD) \
 		.
diff --git a/README.md b/README.md
index 7a29599..3986814 100644
--- a/README.md
+++ b/README.md
@@ -1,52 +1,62 @@
-# charm-k8s-telegraf
+# Telegraf Operator
 
 ## Description
 
-Telegraf is an agent for collecting, processing, aggregating, and writing metrics.
+[Telegraf](https://github.com/influxdata/telegraf) is an agent for collecting, processing, aggregating, and writing metrics.
 
 Telegraf is plugin-driven and has the concept of 4 distinct plugin types:
-    Input Plugins collect metrics from the system, services, or 3rd party APIs
-    Processor Plugins transform, decorate, and/or filter metrics
-    Aggregator Plugins create aggregate metrics (e.g. mean, min, max, quantiles, etc.)
-    Output Plugins write metrics to various destinations
+ - Input Plugins collect metrics from the system, services, or 3rd party APIs
+ - Processor Plugins transform, decorate, and/or filter metrics
+ - Aggregator Plugins create aggregate metrics (e.g. mean, min, max, quantiles, etc.)
+ - Output Plugins write metrics to various destinations
 
-Deploying telegraf in a k8s environment makes sense to monitor services or 3rd party
-APIs, not to gather system stats (telegraf would only monitor itself in its container).
+This telegraf Charmed Operator addresses two use cases:
+ - monitor charmed k8s workoad using a juju relation
+ - monitor a remote service thanks to telegraf's wide range of input plugins
 
-It is possible for instance to deploy telegraf on k8s to gather metrics about a github
-repository with the github input plugin, weather data with the OpenWeatherMap input
-plugin, or check HTTP/HTTPS connections with the http_response plugin.
+It is possible for instance to deploy telegraf on k8s to gather metrics about a github repository with the `github` input plugin, weather data with the `OpenWeatherMap` input plugin, or monitor remote HTTP/HTTPS endpoints with the `http_response` plugin.
 
 ## Usage
 
-Deploy the charm to a k8s juju model, for example:
 
-    juju deploy cs:~telegraf-charmers/telegraf --config inputs='[[inputs.github]]
-      repositories = [
-              "influxdata/telegraf"
-      ]'
-
-In this case, telegraf will expose its metrics using the charm's default output plugin,
-prometheus on tcp port 9103.
-
-## Using a custom image
-
-By default the charm will use the telegrafcharmers/telegraf:edge image from dockerhub.
-To build and push a custom image:
-
-    git clone  https://git.launchpad.net/charm-k8s-telegraf
-    cd charm-k8s-telegraf
-    make image-build
-    docker tag telegraf:latest localhost:32000/telegraf
-    docker push localhost:32000/telegraf
-
-Then, to use your new image, either replace the `deploy` step above with:
-
-    juju deploy ./telegraf.charm --config image_path=localhost:32000/telegraf
-
-or, if you've already deployed telegraf:
-
-    juju config telegraf image_path=localhost:32000/telegraf
+### Monitor a remote service
+
+In this example, we will use telegraf to get metrics about a GitHub repository, using
+the github input plugin:
+```
+juju deploy telegraf-k8s --channel edge --config inputs='[[inputs.github]]\n repositories = ["canonical/operator"]'
+```
+Wait for the unit to be active/idle, and the metrics will be available on the default output (`prometheus_client` on port 9103):
+```
+$ curl -s <unit IP>:9103/metrics | grep github_repository_stars
+# HELP github_repository_stars Telegraf collected metric
+# TYPE github_repository_stars untyped
+github_repository_stars{host="telegraf-k8s-0",language="Python",license="Apache License 2.0",name="operator",owner="canonical"} 98
+```
+
+### Monitor a charmed k8s workload through a Juju relation
+
+In this example, telegraf will get metrics from postgresql:
+
+```
+juju deploy postgresql-k8s
+juju deploy telegraf-k8s --channel edge
+juju relate telegraf-k8s:pg postgresql-k8s:db
+```
+Wait for the units to be active/idle, and then the metrics can be scraped:
+```
+$ curl -s <unit IP>:9103/metrics | grep ^postgresql_
+postgresql_blk_read_time{datname="",db="postgres",host="telegraf-k8s-0",replica="master",server="dbname=telegraf-k8s  host=10.152.183.38 port=5432 user=telegraf-k8s"} 0
+[...]
+```
+
+## Prometheus metrics - service check
+
+By default (and in most cases), the operator will make telegraf expose a prometheus_client endpoint on port tcp/9103.
+This can be easily tested by running the juju action:
+```
+juju run-action telegraf-k8s/0 get-prometheus-metrics --wait
+```
 
 ## Testing
 
diff --git a/actions.yaml b/actions.yaml
new file mode 100644
index 0000000..d26e5f0
--- /dev/null
+++ b/actions.yaml
@@ -0,0 +1,3 @@
+get-prometheus-metrics:
+  description: >
+    Scrape the open port for prometheus metrics
diff --git a/config.yaml b/config.yaml
index fbe14b5..051169d 100644
--- a/config.yaml
+++ b/config.yaml
@@ -53,27 +53,13 @@ options:
 
       This setting is required.
     type: string
-  image_path:
-    type: string
+  open_port:
+    default: '9103'
     description: >
-      The location of the image to use, e.g. "registry.example.com/telegraf:v1".
-
-      This setting is required.
-    default: 'telegrafcharmers/telegraf:edge'
-  image_username:
+      TCP port number to open.
     type: string
-    description: >
-      The username for accessing the registry specified in image_path.
-    default: ''
-  image_password:
+  external_hostname:
     type: string
     description: >
-      The password associated with image_username for accessing the registry specified in image_path.
-    default: ''
-  open_ports:
-    default: '9103:tcp'
-    description: >
-      Comma-separated list of <port number>:<protocol> ports to open. Ex: '9103:tcp,6343:udp'.
-
-      This setting is required. Even if no port needs to be exposed, a dummy one needs to be set lp:1876129.
-    type: string
+      External hostname this agent should respond to (required).
+    default: 'telegraf.internal'
diff --git a/lib/charms/nginx_ingress_integrator/v0/ingress.py b/lib/charms/nginx_ingress_integrator/v0/ingress.py
new file mode 100644
index 0000000..196c314
--- /dev/null
+++ b/lib/charms/nginx_ingress_integrator/v0/ingress.py
@@ -0,0 +1,198 @@
+"""Library for the ingress relation.
+
+This library contains the Requires and Provides classes for handling
+the ingress interface.
+
+Import `IngressRequires` in your charm, with two required options:
+    - "self" (the charm itself)
+    - config_dict
+
+`config_dict` accepts the following keys:
+    - service-hostname (required)
+    - service-name (required)
+    - service-port (required)
+    - limit-rps
+    - limit-whitelist
+    - max-body-size
+    - retry-errors
+    - service-namespace
+    - session-cookie-max-age
+    - tls-secret-name
+
+See [the config section](https://charmhub.io/nginx-ingress-integrator/configure) for descriptions
+of each, along with the required type.
+
+As an example, add the following to `src/charm.py`:
+```
+from charms.nginx_ingress_integrator.v0.ingress import IngressRequires
+
+# In your charm's `__init__` method.
+self.ingress = IngressRequires(self, {"service-hostname": self.config["external_hostname"],
+                                      "service-name": self.app.name,
+                                      "service-port": 80})
+
+# In your charm's `config-changed` handler.
+self.ingress.update_config({"service-hostname": self.config["external_hostname"]})
+```
+And then add the following to `metadata.yaml`:
+```
+requires:
+  ingress:
+    interface: ingress
+```
+"""
+
+import logging
+
+from ops.charm import CharmEvents
+from ops.framework import EventBase, EventSource, Object
+from ops.model import BlockedStatus
+
+# The unique Charmhub library identifier, never change it
+LIBID = "db0af4367506491c91663468fb5caa4c"
+
+# Increment this major API version when introducing breaking changes
+LIBAPI = 0
+
+# Increment this PATCH version before using `charmcraft publish-lib` or reset
+# to 0 if you are raising the major API version
+LIBPATCH = 6
+
+logger = logging.getLogger(__name__)
+
+REQUIRED_INGRESS_RELATION_FIELDS = {
+    "service-hostname",
+    "service-name",
+    "service-port",
+}
+
+OPTIONAL_INGRESS_RELATION_FIELDS = {
+    "limit-rps",
+    "limit-whitelist",
+    "max-body-size",
+    "retry-errors",
+    "service-namespace",
+    "session-cookie-max-age",
+    "tls-secret-name",
+}
+
+
+class IngressAvailableEvent(EventBase):
+    pass
+
+
+class IngressCharmEvents(CharmEvents):
+    """Custom charm events."""
+
+    ingress_available = EventSource(IngressAvailableEvent)
+
+
+class IngressRequires(Object):
+    """This class defines the functionality for the 'requires' side of the 'ingress' relation.
+
+    Hook events observed:
+        - relation-changed
+    """
+
+    def __init__(self, charm, config_dict):
+        super().__init__(charm, "ingress")
+
+        self.framework.observe(charm.on["ingress"].relation_changed, self._on_relation_changed)
+
+        self.config_dict = config_dict
+
+    def _config_dict_errors(self, update_only=False):
+        """Check our config dict for errors."""
+        blocked_message = "Error in ingress relation, check `juju debug-log`"
+        unknown = [
+            x
+            for x in self.config_dict
+            if x not in REQUIRED_INGRESS_RELATION_FIELDS | OPTIONAL_INGRESS_RELATION_FIELDS
+        ]
+        if unknown:
+            logger.error(
+                "Ingress relation error, unknown key(s) in config dictionary found: %s",
+                ", ".join(unknown),
+            )
+            self.model.unit.status = BlockedStatus(blocked_message)
+            return True
+        if not update_only:
+            missing = [x for x in REQUIRED_INGRESS_RELATION_FIELDS if x not in self.config_dict]
+            if missing:
+                logger.error(
+                    "Ingress relation error, missing required key(s) in config dictionary: %s",
+                    ", ".join(missing),
+                )
+                self.model.unit.status = BlockedStatus(blocked_message)
+                return True
+        return False
+
+    def _on_relation_changed(self, event):
+        """Handle the relation-changed event."""
+        # `self.unit` isn't available here, so use `self.model.unit`.
+        if self.model.unit.is_leader():
+            if self._config_dict_errors():
+                return
+            for key in self.config_dict:
+                event.relation.data[self.model.app][key] = str(self.config_dict[key])
+
+    def update_config(self, config_dict):
+        """Allow for updates to relation."""
+        if self.model.unit.is_leader():
+            self.config_dict = config_dict
+            if self._config_dict_errors(update_only=True):
+                return
+            relation = self.model.get_relation("ingress")
+            if relation:
+                for key in self.config_dict:
+                    relation.data[self.model.app][key] = str(self.config_dict[key])
+
+
+class IngressProvides(Object):
+    """This class defines the functionality for the 'provides' side of the 'ingress' relation.
+
+    Hook events observed:
+        - relation-changed
+    """
+
+    def __init__(self, charm):
+        super().__init__(charm, "ingress")
+        # Observe the relation-changed hook event and bind
+        # self.on_relation_changed() to handle the event.
+        self.framework.observe(charm.on["ingress"].relation_changed, self._on_relation_changed)
+        self.charm = charm
+
+    def _on_relation_changed(self, event):
+        """Handle a change to the ingress relation.
+
+        Confirm we have the fields we expect to receive."""
+        # `self.unit` isn't available here, so use `self.model.unit`.
+        if not self.model.unit.is_leader():
+            return
+
+        ingress_data = {
+            field: event.relation.data[event.app].get(field)
+            for field in REQUIRED_INGRESS_RELATION_FIELDS | OPTIONAL_INGRESS_RELATION_FIELDS
+        }
+
+        missing_fields = sorted(
+            [
+                field
+                for field in REQUIRED_INGRESS_RELATION_FIELDS
+                if ingress_data.get(field) is None
+            ]
+        )
+
+        if missing_fields:
+            logger.error(
+                "Missing required data fields for ingress relation: {}".format(
+                    ", ".join(missing_fields)
+                )
+            )
+            self.model.unit.status = BlockedStatus(
+                "Missing fields for ingress: {}".format(", ".join(missing_fields))
+            )
+
+        # Create an event that our charm can use to decide it's okay to
+        # configure the ingress.
+        self.charm.on.ingress_available.emit()
diff --git a/metadata.yaml b/metadata.yaml
index 80f06b7..cd1898c 100644
--- a/metadata.yaml
+++ b/metadata.yaml
@@ -1,11 +1,28 @@
 # Copyright 2020 Canonical Ltd.
 # See LICENSE file for licensing details.
-name: telegraf
+name: telegraf-k8s
+display-name: Telegraf
 description: |
   Telegraf charm for Kubernetes.
   Telegraf is an agent for collecting, processing, aggregating, and writing metrics.
 summary: |
   Telegraf charm for Kubernetes
-series: [kubernetes]
 maintainers:
   - launchpad.net/~telegraf-charmers
+docs: https://discourse.charmhub.io/t/telegraf-k8s-docs-index/4587
+
+containers:
+  telegraf:
+    resource: telegraf-image
+
+resources:
+  telegraf-image:
+    type: oci-image
+    description: Docker image for telegraf to run
+
+requires:
+  pg:
+    interface: pgsql
+    limit: 1
+  ingress:
+    interface: ingress
diff --git a/requirements.txt b/requirements.txt
index 2d81d3b..fd6adcd 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1 +1,2 @@
 ops
+ops-lib-pgsql
diff --git a/src/charm.py b/src/charm.py
index 09d477f..42b0d00 100755
--- a/src/charm.py
+++ b/src/charm.py
@@ -2,22 +2,77 @@
 # Copyright 2020 Canonical Ltd.
 # See LICENSE file for licensing details.
 
+from jinja2 import Environment, BaseLoader
+from urllib.error import HTTPError
 import logging
+import pgsql
+import re
+import urllib.request
+import yaml
 
+from charms.nginx_ingress_integrator.v0.ingress import IngressRequires
 import ops
 from ops.charm import CharmBase
-from ops.main import main
 from ops.framework import StoredState
+from ops.main import main
 from ops.model import (
     ActiveStatus,
     BlockedStatus,
-    MaintenanceStatus,
 )
+from ops.pebble import ServiceStatus
 
 
 logger = logging.getLogger(__name__)
 
-REQUIRED_JUJU_CONFIG = ['image_path', 'inputs', 'outputs', 'open_ports']
+REQUIRED_JUJU_CONFIG = ['inputs', 'outputs', 'open_port']
+TELEGRAF_CONFIG_FILE = '/etc/telegraf.conf'
+
+POSTGRESQL_TEMPLATE = '''
+{%- if conn_str %}
+[[inputs.postgresql_extensible]]
+  address = "{{conn_str}}"
+  [inputs.postgresql_extensible.tags]
+    replica = "master"
+
+[[inputs.postgresql_extensible.query]]
+  sqlquery="SELECT * FROM pg_stat_database"
+  version=901
+  withdbname=false
+  tagvalue=""
+
+[[inputs.postgresql_extensible.query]]
+  sqlquery="SELECT * FROM pg_stat_bgwriter"
+  version=901
+  withdbname=false
+  tagvalue=""
+
+[[inputs.postgresql_extensible.query]]
+  withdbname=false
+  tagvalue=""
+  sqlquery="""
+    SELECT
+      datname,
+      EXTRACT(EPOCH FROM clock_timestamp() - MIN(xact_start)) AS oldest_xact,
+      EXTRACT(EPOCH FROM clock_timestamp()
+        - MIN(CASE WHEN state='active' THEN query_start ELSE NULL END)) AS oldest_query,
+      COUNT(NULLIF(wait_event_type IS NOT NULL AND wait_event_type <> 'Activity', False)) AS queries_waiting
+    FROM pg_stat_activity
+    GROUP BY datname"""
+
+[[inputs.postgresql_extensible.query]]
+  withdbname=false
+  tagvalue="transaction_state"
+  sqlquery="""
+    SELECT
+      datname,
+      CASE WHEN state='active' AND wait_event_type IS NOT NULL THEN 'blocked'
+      ELSE state END AS transaction_state,
+      COUNT(*) AS connections
+    FROM pg_stat_activity
+    WHERE state IS NOT NULL
+    GROUP BY datname, state, wait_event_type"""
+{%- endif %}
+'''
 
 
 class TelegrafK8sCharmJujuConfigError(Exception):
@@ -30,10 +85,174 @@ class TelegrafK8sCharm(CharmBase):
     def __init__(self, *args):
         super().__init__(*args)
 
-        self.framework.observe(self.on.start, self._configure_pod)
-        self.framework.observe(self.on.config_changed, self._configure_pod)
-        self.framework.observe(self.on.leader_elected, self._configure_pod)
-        self.framework.observe(self.on.upgrade_charm, self._configure_pod)
+        self.framework.observe(self.on.config_changed, self._on_config_changed)
+        self.framework.observe(self.on.upgrade_charm, self._on_upgrade_charm)
+        self.framework.observe(self.on.telegraf_pebble_ready, self._on_telegraf_pebble_ready)
+
+        # actions
+        self.framework.observe(self.on.get_prometheus_metrics_action, self.on_get_prometheus_metrics_action)
+
+        self.ingress = IngressRequires(
+            self,
+            {
+                "service-hostname": self.config["external_hostname"],
+                "service-name": self.app.name,
+                "service-port": self.config["open_port"],
+            },
+        )
+
+        self._stored.set_default(telegraf_pebble_ready=False, reldata={})
+
+        self._init_postgresql_relation()
+
+    def _get_pebble_config(self, event: ops.framework.EventBase) -> dict:
+        """Generate pebble config."""
+        pebble_config = {
+            "summary": "telegraf layer",
+            "description": "telegraf layer",
+            "services": {
+                "telegraf": {
+                    "override": "replace",
+                    "summary": "telegraf service",
+                    "command": "/run_telegraf",
+                    "startup": "enabled",
+                }
+            },
+        }
+
+        try:
+            self._check_juju_config()
+        except TelegrafK8sCharmJujuConfigError as e:
+            self.unit.status = BlockedStatus(str(e))
+            return {}
+
+        # Update pod environment config.
+        pebble_config["services"]["telegraf"]["environment"] = self._make_pod_env()
+
+        return pebble_config
+
+    def _on_config_changed(self, event: ops.framework.EventBase) -> None:
+        """Handle the config changed event."""
+        if not self._stored.telegraf_pebble_ready:
+            logger.info(
+                "Got a config changed event, but the workload isn't ready yet. Doing nothing, config will be "
+                "picked up when workload is ready."
+            )
+            event.defer()
+            return
+
+        pebble_config = self._get_pebble_config(event)
+        if not pebble_config:
+            # Charm will be in blocked status.
+            return
+
+        # Ensure the ingress relation has the external hostname and port.
+        self.ingress.update_config({"service-hostname": self.config["external_hostname"]})
+        self.ingress.update_config({"service-name": self.app.name})
+        self.ingress.update_config({"service-port": self.config["open_port"]})
+
+        container = self.unit.get_container("telegraf")
+        plan = container.get_plan().to_dict()
+        if plan["services"] != pebble_config["services"]:
+            container.add_layer("telegraf", pebble_config, combine=True)
+
+            status = container.get_service("telegraf")
+            if status.current == ServiceStatus.ACTIVE:
+                container.stop("telegraf")
+            container.start("telegraf")
+
+        self.unit.status = ActiveStatus()
+
+    def _on_upgrade_charm(self, event: ops.framework.EventBase) -> None:
+        """Handle the upgrade charm event."""
+        # An 'upgrade-charm' hook (which will also be triggered by an
+        # 'attach-resource' event) will cause the pod to be rescheduled:
+        # even though the name remains the same, the IP may change.
+        # The workload won't be running, so we need to handle that in the
+        # course of subsequent events that will be triggered after this.
+        #
+        # Setting pebble_ready to `False` will ensure a 'config-changed'
+        # hook waits for the workload to be ready before doing anything.
+        self._stored.telegraf_pebble_ready = False
+        # An upgrade-charm hook will be followed by others such as config-changed
+        # and workload-ready, so just do nothing else for now.
+        return
+
+    def _on_telegraf_pebble_ready(self, event: ops.framework.EventBase) -> None:
+        """Handle the workload ready event."""
+        self._stored.telegraf_pebble_ready = True
+
+        pebble_config = self._get_pebble_config(event)
+        if not pebble_config:
+            # Charm will be in blocked status.
+            return
+
+        container = event.workload
+        logger.debug("About to add_layer with pebble_config:\n{}".format(yaml.dump(pebble_config)))
+        # `container.add_layer` accepts str (YAML) or dict or pebble.Layer
+        # object directly.
+        container.add_layer("telegraf", pebble_config)
+        # Start the container and set status.
+        container.autostart()
+        self.unit.status = ActiveStatus()
+
+    def _init_postgresql_relation(self) -> None:
+        """Initialization related to the postgresql relation"""
+        if 'pg' not in self._stored.reldata:
+            self._stored.reldata['pg'] = {}
+        self.pg = pgsql.PostgreSQLClient(self, 'pg')
+        self.framework.observe(self.on.pg_relation_changed, self._on_config_changed)
+        self.framework.observe(self.pg.on.database_relation_joined, self._on_database_relation_joined)
+        self.framework.observe(self.pg.on.master_changed, self._on_master_changed)
+        self.framework.observe(self.pg.on.standby_changed, self._on_standby_changed)
+
+    def _on_database_relation_joined(self, event: pgsql.DatabaseRelationJoinedEvent) -> None:
+        """Handle db-relation-joined."""
+        if self.model.unit.is_leader():
+            # Provide requirements to the PostgreSQL server.
+            event.database = self.app.name  # Request database named like the Juju app
+        elif event.database != self.app.name:
+            # Leader has not yet set requirements. Defer, in case this unit
+            # becomes leader and needs to perform that operation.
+            event.defer()
+
+    def _on_master_changed(self, event: pgsql.MasterChangedEvent) -> None:
+        """Handle changes in the primary database unit."""
+        if event.database != self.app.name:
+            # Leader has not yet set requirements. Wait until next
+            # event, or risk connecting to an incorrect database.
+            return
+
+        self._stored.reldata['pg']['conn_str'] = None if event.master is None else event.master.conn_str
+        self._stored.reldata['pg']['db_uri'] = None if event.master is None else event.master.uri
+
+        if event.master is None:
+            return
+
+    def _remove_fallback_application_name_from_conn_str(self, conn_str):
+        """Remove the fallback_application_name from conn_str as it's making telegraf Error."""
+
+        pattern = r'fallback_application_name=[^\s]+'
+        return re.sub(pattern, '', conn_str)
+
+    def _on_standby_changed(self, event: pgsql.StandbyChangedEvent) -> None:
+        """Handle changes in the secondary database unit(s)."""
+        if event.database != self.app.name:
+            # Leader has not yet set requirements. Wait until next
+            # event, or risk connecting to an incorrect database.
+            return
+
+        self._stored.reldata['pg']['ro_uris'] = [c.uri for c in event.standbys]
+
+        # TODO: Emit event when we add support for read replicas
+
+    def on_get_prometheus_metrics_action(self, event):
+        """Handle the get-prometheus-metrics action."""
+        try:
+            response = urllib.request.urlopen('http://127.0.0.1:{}/metrics'.format(self.config["open_port"]))
+            event.set_results({"prometheus-metrics": response.read(), "result-code": response.status})
+        except HTTPError as error:
+            event.set_results({"result-code": error.code})
 
     def _make_pod_env(self) -> dict:
         """Return an envConfig with some core configuration.
@@ -43,11 +262,16 @@ class TelegrafK8sCharm(CharmBase):
 
         config = self.model.config
 
+        inputs = config['inputs']
+        if self._stored.reldata['pg'] and self._stored.reldata['pg']['conn_str']:
+            conn_str = self._remove_fallback_application_name_from_conn_str(self._stored.reldata['pg']['conn_str'])
+            inputs = inputs + self._render_template(POSTGRESQL_TEMPLATE, {'conn_str': conn_str})
+
         return {
             'GLOBAL_TAGS': config['global_tags'],
             'AGENT_CONF': config['agent_conf'],
             'OUTPUTS': config['outputs'],
-            'INPUTS': config['inputs'],
+            'INPUTS': inputs,
         }
 
     def _check_juju_config(self) -> None:
@@ -72,100 +296,28 @@ class TelegrafK8sCharm(CharmBase):
                 "Required Juju config item(s) not set : {}".format(", ".join(sorted(errors)))
             )
 
-        port_list = self.model.config['open_ports']
-        for port in port_list.split(","):
-            try:
-                [number, protocol] = port.split(":")
-                number_int = int(number)
-                if number_int < 1024 or number_int >= 65535:
-                    logger.error("open_ports wants to open a port out of range: %s", number)
-                    raise TelegrafK8sCharmJujuConfigError(
-                        "open_ports wants to open a port out of range: {}".format(number)
-                    )
-                if protocol.upper() not in ['TCP', 'UDP']:
-                    logger.error(
-                        "open_ports has wrong format: %s. %s is not a valid protocol. 'tcp' or 'udp' expected.",
-                        port,
-                        protocol,
-                    )
-                    raise TelegrafK8sCharmJujuConfigError(
-                        "open_ports has wrong format: {}. {} is not a valid protocol. 'tcp' or 'udp' expected.".format(
-                            port, protocol
-                        )
-                    )
-            except ValueError as e:
-                logger.error("Failed to parse open_ports: %s", e)
-                raise TelegrafK8sCharmJujuConfigError("Failed to parse open_ports: {}".format(str(e)))
-
-    def _make_open_ports_list(self) -> dict:
-        """Return a list of ports to be opened from config['open_ports'].
-
-        :returns: A list of dicts used for ports in podspec
-        """
-
-        open_ports = self.model.config['open_ports']
-        if open_ports == '':
-            return None
-        open_ports_list = []
-        for port in open_ports.split(","):
-            number, proto = port.split(":")
-            open_ports_list.append(
-                {'containerPort': int(number), 'protocol': proto.upper(), 'name': '{}-{}'.format(number, proto)}
-            )
-
-        return open_ports_list
-
-    def _make_pod_spec(self) -> dict:
-        """Create a pod spec with some core configuration."""
-
-        config = self.model.config
-        image_details = {
-            'imagePath': config['image_path'],
-        }
-        if config.get('image_username', None):
-            image_details.update({'username': config['image_username'], 'password': config['image_password']})
-        pod_env = self._make_pod_env()
-        open_ports = self._make_open_ports_list()
-
-        return {
-            'version': 3,  # otherwise resources are ignored
-            'containers': [
-                {
-                    'name': self.app.name,
-                    "imageDetails": image_details,
-                    # TODO: debatable. The idea is that if you want to force an update with the same image name, you
-                    # don't need to empty kubelet cache on each node to have the right version.
-                    # This implies a performance drop upon start.
-                    "imagePullPolicy": "Always",
-                    "ports": open_ports,
-                    "envConfig": pod_env,
-                },
-            ],
-        }
-
-    def _configure_pod(self, event: ops.framework.EventBase) -> None:
-        """Assemble the pod spec and apply it, if possible.
-
-        :param event: Event that triggered the method.
-        """
-
-        if not self.unit.is_leader():
-            self.unit.status = ActiveStatus()
-            return
-
+        port = self.model.config['open_port']
         try:
-            self._check_juju_config()
-        except TelegrafK8sCharmJujuConfigError as e:
-            self.unit.status = BlockedStatus(str(e))
-            return
-
-        self.model.unit.status = MaintenanceStatus('Configuring pod')
-
-        pod_spec = self._make_pod_spec()
+            port_int = int(port)
+            if port_int < 1024 or port_int >= 65535:
+                logger.error("open_port wants to open a port out of range: %s", port_int)
+                raise TelegrafK8sCharmJujuConfigError(
+                    "open_port wants to open a port out of range: {}".format(port_int)
+                )
+        except ValueError as e:
+            logger.error("Failed to parse open_port: %s", e)
+            raise TelegrafK8sCharmJujuConfigError("Failed to parse open_port: {}".format(str(e)))
+
+    def _render_template(self, tmpl: str, ctx: dict) -> str:
+        """Render a Jinja2 template
+
+        :returns: A rendered Jinja2 template
+        """
+        j2env = Environment(loader=BaseLoader())
+        j2template = j2env.from_string(tmpl)
 
-        self.model.pod.set_spec(pod_spec)
-        self.unit.status = ActiveStatus()
+        return j2template.render(**ctx)
 
 
 if __name__ == "__main__":  # pragma: no cover
-    main(TelegrafK8sCharm)
+    main(TelegrafK8sCharm, use_juju_for_storage=True)
diff --git a/tests/unit/requirements.txt b/tests/unit/requirements.txt
index 65431fc..6dd0825 100644
--- a/tests/unit/requirements.txt
+++ b/tests/unit/requirements.txt
@@ -1,3 +1,4 @@
+jinja2
 mock
 pytest
 pytest-cov
diff --git a/tests/unit/scenario.py b/tests/unit/scenario.py
index e60569b..2a05beb 100644
--- a/tests/unit/scenario.py
+++ b/tests/unit/scenario.py
@@ -39,52 +39,30 @@ TEST_JUJU_CONFIG = {
         'logger': ["ERROR:charm:Required Juju config item(s) not set : inputs"],
         'expected': 'Required Juju config item(s) not set : inputs',
     },
-    'good_config': {
-        'config': {'image_path': 'telegraf:latest'},
-        'logger': [],
-        'expected': False,
-    },
     'empty_ports_list': {
         'config': {
-            'open_ports': '',
+            'open_port': '',
         },
-        'logger': ['ERROR:charm:Required Juju config item(s) not set : open_ports'],
-        'expected': 'Required Juju config item(s) not set : open_ports',
+        'logger': ['ERROR:charm:Required Juju config item(s) not set : open_port'],
+        'expected': 'Required Juju config item(s) not set : open_port',
     },
     'port_out_of_range': {
         'config': {
-            'open_ports': '9103:tcp,-1:udp',
-            'inputs': '[[inputs.internal]]',
-            'outputs': '[[outputs.prometheus_client]]',
-        },
-        'logger': ['ERROR:charm:open_ports wants to open a port out of range: -1'],
-        'expected': 'open_ports wants to open a port out of range: -1',
-    },
-    'invalid_protocol': {
-        'config': {
-            'open_ports': '9103:tcp,6343:wrong_protocol',
+            'open_port': '10',
             'inputs': '[[inputs.internal]]',
             'outputs': '[[outputs.prometheus_client]]',
         },
-        'logger': [
-            (
-                "ERROR:charm:open_ports has wrong format: 6343:wrong_protocol. wrong_protocol is not a "
-                "valid protocol. 'tcp' or 'udp' expected."
-            )
-        ],
-        'expected': (
-            "open_ports has wrong format: 6343:wrong_protocol. wrong_protocol is not a valid "
-            "protocol. 'tcp' or 'udp' expected."
-        ),
+        'logger': ['ERROR:charm:open_port wants to open a port out of range: 10'],
+        'expected': 'open_port wants to open a port out of range: 10',
     },
     'invalid_port_number': {
         'config': {
-            'open_ports': 'not_an_int:tcp',
+            'open_port': 'not_an_int',
             'inputs': '[[inputs.internal]]',
             'outputs': '[[outputs.prometheus_client]]',
         },
-        'logger': [("ERROR:charm:Failed to parse open_ports: invalid literal for int() with base 10: 'not_an_int'")],
-        'expected': ("Failed to parse open_ports: invalid literal for int() with base 10: 'not_an_int'"),
+        'logger': [("ERROR:charm:Failed to parse open_port: invalid literal for int() with base 10: 'not_an_int'")],
+        'expected': ("Failed to parse open_port: invalid literal for int() with base 10: 'not_an_int'"),
     },
 }
 
@@ -109,76 +87,40 @@ TEST_MAKE_POD_ENV = {
     },
 }
 
-TEST_MAKE_OPEN_PORTS_LIST = {
-    'good_config': {
-        'config': {
-            'open_ports': '9103:tcp,6343:udp',
-        },
-        'expected_ret': [
-            {'containerPort': 9103, 'protocol': 'TCP', 'name': '9103-tcp'},
-            {'containerPort': 6343, 'protocol': 'UDP', 'name': '6343-udp'},
-        ],
-    },
-    'empty_open_ports': {
+TEST_GET_PEBBLE_CONFIG = {
+    'invalid_port_number': {
         'config': {
-            'open_ports': '',
+            'open_port': 'not_an_int',
+            'inputs': '[[inputs.internal]]',
+            'outputs': '[[outputs.prometheus_client]]',
         },
-        'expected_ret': None,
+        'logger': [("ERROR:charm:Failed to parse open_port: invalid literal for int() with base 10: 'not_an_int'")],
+        'expected_ret': {},
     },
-}
-
-TEST_MAKE_POD_SPEC = {
-    'basic': {
+    'good_config': {
         'config': {
-            'agent_conf': ('[agent]\n' ' interval = "10s"\n' ' round_interval = true'),
+            'agent_conf': '[agent]',
+            'global_tags': '[global_tags]',
+            'inputs': '[[inputs.internal]]',
+            'outputs': '[[outputs.prometheus_client]]\n  listen = ":9103"',
         },
-        'pod_spec': {
-            'version': 3,  # otherwise resources are ignored
-            'containers': [
-                {
-                    'name': 'telegraf',
-                    'imageDetails': {
-                        'imagePath': 'telegrafcharmers/telegraf:edge',
-                    },
-                    'imagePullPolicy': 'Always',
-                    'ports': [{'containerPort': 9103, 'protocol': 'TCP', 'name': '9103-tcp'}],
-                    'envConfig': {
-                        'GLOBAL_TAGS': '[global_tags]',
-                        'AGENT_CONF': ('[agent]\n' ' interval = "10s"\n' ' round_interval = true'),
-                        'OUTPUTS': '[[outputs.prometheus_client]]\n  listen = ":9103"',
-                        'INPUTS': '[[inputs.internal]]\n  collect_memstats = true',
+        'expected_ret': {
+            "summary": "telegraf layer",
+            "description": "telegraf layer",
+            "services": {
+                "telegraf": {
+                    "environment": {
+                        "AGENT_CONF": "[agent]",
+                        "GLOBAL_TAGS": "[global_tags]",
+                        "INPUTS": "[[inputs.internal]]",
+                        "OUTPUTS": '[[outputs.prometheus_client]]\n  listen = ":9103"',
                     },
+                    "override": "replace",
+                    "summary": "telegraf service",
+                    "command": "/run_telegraf",
+                    "startup": "enabled",
                 }
-            ],
-        },
-    },
-    'basic_with_image_username_and_password': {
-        'config': {
-            'image_path': 'telegraf:latest',
-            'image_username': 'test_user',
-            'image_password': 'test_password',
-            'agent_conf': ('[agent]\n' ' interval = "10s"\n' ' round_interval = true'),
-        },
-        'pod_spec': {
-            'version': 3,  # otherwise resources are ignored
-            'containers': [
-                {
-                    'name': 'telegraf',
-                    'imageDetails': {
-                        'imagePath': 'telegraf:latest',
-                        'username': 'test_user',
-                        'password': 'test_password',
-                    },
-                    'imagePullPolicy': 'Always',
-                    'ports': [{'containerPort': 9103, 'protocol': 'TCP', 'name': '9103-tcp'}],
-                    'envConfig': {
-                        'GLOBAL_TAGS': '[global_tags]',
-                        'AGENT_CONF': ('[agent]\n' ' interval = "10s"\n' ' round_interval = true'),
-                        'OUTPUTS': '[[outputs.prometheus_client]]\n  listen = ":9103"',
-                        'INPUTS': '[[inputs.internal]]\n  collect_memstats = true',
-                    },
-                },
-            ],
+            },
         },
     },
 }
diff --git a/tests/unit/test_charm.py b/tests/unit/test_charm.py
index 3ee5524..8bc6047 100644
--- a/tests/unit/test_charm.py
+++ b/tests/unit/test_charm.py
@@ -7,10 +7,6 @@ import unittest
 from unittest.mock import MagicMock
 
 from ops import testing
-from ops.model import (
-    ActiveStatus,
-    BlockedStatus,
-)
 from charm import (
     TelegrafK8sCharm,
     TelegrafK8sCharmJujuConfigError,
@@ -18,10 +14,9 @@ from charm import (
 
 from scenario import (
     JUJU_DEFAULT_CONFIG,
+    TEST_GET_PEBBLE_CONFIG,
     TEST_JUJU_CONFIG,
-    TEST_MAKE_OPEN_PORTS_LIST,
     TEST_MAKE_POD_ENV,
-    TEST_MAKE_POD_SPEC,
 )
 
 
@@ -49,45 +44,15 @@ class TestTelegrafK8sCharm(unittest.TestCase):
                 self.assertEqual(self.harness.charm._make_pod_env(), values['expected_ret'])
                 self.harness.update_config(JUJU_DEFAULT_CONFIG)  # You need to clean the config after each run
 
-    def test_make_pod_spec(self):
-        """Check the crafting of the pod spec."""
-
-        self.harness.update_config(JUJU_DEFAULT_CONFIG)
-
-        for scenario, values in TEST_MAKE_POD_SPEC.items():
-            with self.subTest(scenario=scenario):
-                self.harness.update_config(values['config'])
-                self.assertEqual(self.harness.charm._make_pod_spec(), values['pod_spec'])
-                self.harness.update_config(JUJU_DEFAULT_CONFIG)  # You need to clean the config after each run
-
-    def test_configure_pod(self):
-        """Test the pod configuration."""
+    def test_get_pebble_config(self):
+        """Test the _get_pebble_config function."""
         mock_event = MagicMock()
-
-        self.harness.update_config(JUJU_DEFAULT_CONFIG)
-
-        for is_leader in [True, False]:
-            self.harness.set_leader(is_leader)
-            self.harness.charm.unit.status = BlockedStatus("Testing")
-            self.harness.charm._configure_pod(mock_event)
-            self.assertEqual(self.harness.charm.unit.status, ActiveStatus())
-            self.harness.update_config(JUJU_DEFAULT_CONFIG)  # You need to clean the config after each run
-
-        self.harness.set_leader(True)
-        self.harness.update_config({'inputs': ''})
-        self.harness.charm._configure_pod(mock_event)
-        self.assertEqual(self.harness.charm.unit.status, BlockedStatus("Required Juju config item(s) not set : inputs"))
-        self.harness.update_config(JUJU_DEFAULT_CONFIG)  # You need to clean the config after each run
-
-    def test_make_open_ports_list(self):
-        """Test the _make_open_ports_list function."""
-
         self.harness.update_config(JUJU_DEFAULT_CONFIG)
 
-        for scenario, values in TEST_MAKE_OPEN_PORTS_LIST.items():
+        for scenario, values in TEST_GET_PEBBLE_CONFIG.items():
             with self.subTest(scenario=scenario):
                 self.harness.update_config(values['config'])
-                self.assertEqual(self.harness.charm._make_open_ports_list(), values['expected_ret'])
+                self.assertEqual(self.harness.charm._get_pebble_config(mock_event), values['expected_ret'])
                 self.harness.update_config(JUJU_DEFAULT_CONFIG)  # You need to clean the config after each run
 
     def test_check_juju_config(self):