installers/charm/prometheus/src/charm.py

   1 #!/usr/bin/env python3
   2 # Copyright 2021 Canonical Ltd.
   3 #
   4 # Licensed under the Apache License, Version 2.0 (the "License"); you may
   5 # not use this file except in compliance with the License. You may obtain
   6 # a copy of the License at
   7 #
   8 #         http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 # Unless required by applicable law or agreed to in writing, software
  11 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  12 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  13 # License for the specific language governing permissions and limitations
  14 # under the License.
  15 #
  16 # For those usages not covered by the Apache License, Version 2.0 please
  17 # contact: legal@canonical.com
  18 #
  19 # To get in touch with the maintainers, please contact:
  20 # osm-charmers@lists.launchpad.net
  21 ##
  22
  23 # pylint: disable=E0213
  24
  25 from ipaddress import ip_network
  26 import logging
  27 from typing import NoReturn, Optional
  28 from urllib.parse import urlparse
  29
  30 from oci_image import OCIImageResource
  31 from ops.framework import EventBase
  32 from ops.main import main
  33 from opslib.osm.charm import CharmedOsmBase
  34 from opslib.osm.interfaces.prometheus import PrometheusServer
  35 from opslib.osm.pod import (
  36     ContainerV3Builder,
  37     FilesV3Builder,
  38     IngressResourceV3Builder,
  39     PodSpecV3Builder,
  40 )
  41 from opslib.osm.validator import (
  42     ModelValidator,
  43     validator,
  44 )
  45 import requests
  46
  47
  48 logger = logging.getLogger(__name__)
  49
  50 PORT = 9090
  51
  52
  53 class ConfigModel(ModelValidator):
  54     web_subpath: str
  55     default_target: str
  56     max_file_size: int
  57     site_url: Optional[str]
  58     cluster_issuer: Optional[str]
  59     ingress_class: Optional[str]
  60     ingress_whitelist_source_range: Optional[str]
  61     tls_secret_name: Optional[str]
  62     enable_web_admin_api: bool
  63     image_pull_policy: str
  64     security_context: bool
  65
  66     @validator("web_subpath")
  67     def validate_web_subpath(cls, v):
  68         if len(v) < 1:
  69             raise ValueError("web-subpath must be a non-empty string")
  70         return v
  71
  72     @validator("max_file_size")
  73     def validate_max_file_size(cls, v):
  74         if v < 0:
  75             raise ValueError("value must be equal or greater than 0")
  76         return v
  77
  78     @validator("site_url")
  79     def validate_site_url(cls, v):
  80         if v:
  81             parsed = urlparse(v)
  82             if not parsed.scheme.startswith("http"):
  83                 raise ValueError("value must start with http")
  84         return v
  85
  86     @validator("ingress_whitelist_source_range")
  87     def validate_ingress_whitelist_source_range(cls, v):
  88         if v:
  89             ip_network(v)
  90         return v
  91
  92     @validator("image_pull_policy")
  93     def validate_image_pull_policy(cls, v):
  94         values = {
  95             "always": "Always",
  96             "ifnotpresent": "IfNotPresent",
  97             "never": "Never",
  98         }
  99         v = v.lower()
 100         if v not in values.keys():
 101             raise ValueError("value must be always, ifnotpresent or never")
 102         return values[v]
 103
 104
 105 class PrometheusCharm(CharmedOsmBase):
 106
 107     """Prometheus Charm."""
 108
 109     def __init__(self, *args) -> NoReturn:
 110         """Prometheus Charm constructor."""
 111         super().__init__(*args, oci_image="image")
 112
 113         # Registering provided relation events
 114         self.prometheus = PrometheusServer(self, "prometheus")
 115         self.framework.observe(
 116             self.on.prometheus_relation_joined,  # pylint: disable=E1101
 117             self._publish_prometheus_info,
 118         )
 119
 120         # Registering actions
 121         self.framework.observe(
 122             self.on.backup_action,  # pylint: disable=E1101
 123             self._on_backup_action,
 124         )
 125
 126     def _publish_prometheus_info(self, event: EventBase) -> NoReturn:
 127         self.prometheus.publish_info(self.app.name, PORT)
 128
 129     def _on_backup_action(self, event: EventBase) -> NoReturn:
 130         url = f"http://{self.model.app.name}:{PORT}/api/v1/admin/tsdb/snapshot"
 131         result = requests.post(url)
 132
 133         if result.status_code == 200:
 134             event.set_results({"backup-name": result.json()["name"]})
 135         else:
 136             event.fail(f"status-code: {result.status_code}")
 137
 138     def _build_files(self, config: ConfigModel):
 139         files_builder = FilesV3Builder()
 140         files_builder.add_file(
 141             "prometheus.yml",
 142             (
 143                 "global:\n"
 144                 "  scrape_interval: 15s\n"
 145                 "  evaluation_interval: 15s\n"
 146                 "alerting:\n"
 147                 "  alertmanagers:\n"
 148                 "    - static_configs:\n"
 149                 "        - targets:\n"
 150                 "rule_files:\n"
 151                 "scrape_configs:\n"
 152                 "  - job_name: 'prometheus'\n"
 153                 "    static_configs:\n"
 154                 f"      - targets: [{config.default_target}]\n"
 155             ),
 156         )
 157         return files_builder.build()
 158
 159     def build_pod_spec(self, image_info):
 160         # Validate config
 161         config = ConfigModel(**dict(self.config))
 162         # Create Builder for the PodSpec
 163         pod_spec_builder = PodSpecV3Builder(
 164             enable_security_context=config.security_context
 165         )
 166
 167         # Build Backup Container
 168         backup_image = OCIImageResource(self, "backup-image")
 169         backup_image_info = backup_image.fetch()
 170         backup_container_builder = ContainerV3Builder("prom-backup", backup_image_info)
 171         backup_container = backup_container_builder.build()
 172         # Add backup container to pod spec
 173         pod_spec_builder.add_container(backup_container)
 174
 175         # Build Container
 176         container_builder = ContainerV3Builder(
 177             self.app.name,
 178             image_info,
 179             config.image_pull_policy,
 180             run_as_non_root=config.security_context,
 181         )
 182         container_builder.add_port(name=self.app.name, port=PORT)
 183         container_builder.add_http_readiness_probe(
 184             "/-/ready",
 185             PORT,
 186             initial_delay_seconds=10,
 187             timeout_seconds=30,
 188         )
 189         container_builder.add_http_liveness_probe(
 190             "/-/healthy",
 191             PORT,
 192             initial_delay_seconds=30,
 193             period_seconds=30,
 194         )
 195         command = [
 196             "/bin/prometheus",
 197             "--config.file=/etc/prometheus/prometheus.yml",
 198             "--storage.tsdb.path=/prometheus",
 199             "--web.console.libraries=/usr/share/prometheus/console_libraries",
 200             "--web.console.templates=/usr/share/prometheus/consoles",
 201             f"--web.route-prefix={config.web_subpath}",
 202             f"--web.external-url=http://localhost:{PORT}{config.web_subpath}",
 203         ]
 204         if config.enable_web_admin_api:
 205             command.append("--web.enable-admin-api")
 206         container_builder.add_command(command)
 207         container_builder.add_volume_config(
 208             "config", "/etc/prometheus", self._build_files(config)
 209         )
 210         container = container_builder.build()
 211         # Add container to pod spec
 212         pod_spec_builder.add_container(container)
 213         # Add ingress resources to pod spec if site url exists
 214         if config.site_url:
 215             parsed = urlparse(config.site_url)
 216             annotations = {
 217                 "nginx.ingress.kubernetes.io/proxy-body-size": "{}".format(
 218                     str(config.max_file_size) + "m"
 219                     if config.max_file_size > 0
 220                     else config.max_file_size
 221                 )
 222             }
 223             if config.ingress_class:
 224                 annotations["kubernetes.io/ingress.class"] = config.ingress_class
 225             ingress_resource_builder = IngressResourceV3Builder(
 226                 f"{self.app.name}-ingress", annotations
 227             )
 228
 229             if config.ingress_whitelist_source_range:
 230                 annotations[
 231                     "nginx.ingress.kubernetes.io/whitelist-source-range"
 232                 ] = config.ingress_whitelist_source_range
 233
 234             if config.cluster_issuer:
 235                 annotations["cert-manager.io/cluster-issuer"] = config.cluster_issuer
 236
 237             if parsed.scheme == "https":
 238                 ingress_resource_builder.add_tls(
 239                     [parsed.hostname], config.tls_secret_name
 240                 )
 241             else:
 242                 annotations["nginx.ingress.kubernetes.io/ssl-redirect"] = "false"
 243
 244             ingress_resource_builder.add_rule(parsed.hostname, self.app.name, PORT)
 245             ingress_resource = ingress_resource_builder.build()
 246             pod_spec_builder.add_ingress_resource(ingress_resource)
 247         return pod_spec_builder.build()
 248
 249
 250 if __name__ == "__main__":
 251     main(PrometheusCharm)