Grafana Archives - XpresServers

Using Grafana Loki with Object Storage

Access Denied

You don’t have permission to access “http://www.linode.com/docs/products/storage/object-storage/guides/grafana-loki/” on this server.

Reference #18.8c7c4217.1712746015.814172c

https://errors.edgesuite.net/18.8c7c4217.1712746015.814172c

How to Deploy Prometheus Operator and Grafana on Linode Kubernetes Engine

Updated Wednesday, July 29, 2020 by Linode Written by Ben Bigger

In this guide, you will deploy the Prometheus Operator to your Linode Kubernetes Engine (LKE) cluster using Helm, either as:

The Prometheus Operator Monitoring Stack

When administrating any system, effective monitoring tools can empower users to perform quick and effective issue diagnosis and resolution. This need for monitoring solutions has led to the development of several prominent open source tools designed to solve problems associated with monitoring diverse systems.

Since its release in 2016, Prometheus has become a leading monitoring tool for containerized environments including Kubernetes. Alertmanager is often used with Prometheus to send and manage alerts with tools such as Slack. Grafana, an open source visualization tool with a robust web interface, is commonly deployed along with Prometheus to provide centralized visualization of system metrics.

The community-supported Prometheus Operator Helm Chart provides a complete monitoring stack including each of these tools along with Node Exporter and kube-state-metrics, and is designed to provide robust Kubernetes monitoring in its default configuration.

While there are several options for deploying the Prometheus Operator, using Helm, a Kubernetes “package manager,” to deploy the community-supported the Prometheus Operator enables you to:

Control the components of your monitoring stack with a single configuration file.
Easily manage and upgrade your deployments.
Utilize out-of-the-box Grafana interfaces built for Kubernetes monitoring.

Before You Begin

Note

Deploy an LKE Cluster. This guide was written using an example node pool with three 2 GB Linodes. Depending on the workloads you will be deploying on your cluster, you may consider using Linodes with more available resources.
Install Helm 3 to your local environment.
Install kubectl to your local environment and connect to your cluster.
Create the monitoring namespace on your LKE cluster:
```
kubectl create namespace monitoring
```
Create a directory named lke-monitor to store all of your Helm values and Kubernetes manifest files and move into the new directory:
```
mkdir ~/lke-monitor && cd ~/lke-monitor
```

Add the Google stable Helm charts repository to your Helm repos:

helm repo add stable https://kubernetes-charts.storage.googleapis.com/

Update your Helm repositories:
```
helm repo update
```
(Optional) For public access with HTTPS and basic auth configured for your web interfaces of your monitoring tools:
- Purchase a domain name from a reliable domain registrar and configure your registrar to use Linode’s nameservers with your domain. Using Linode’s DNS Manager, create a new Domain for the one that you have purchased.
- Ensure that htpasswd is installed to your local environment. For many systems, this tool has already been installed. Debian and Ubuntu users will have to install the apache2-utils package with the following command:
```
sudo apt install apache2-utils
```

Prometheus Operator Minimal Deployment

In this section, you will complete a minimal deployment of the Prometheus Operator for individual/local access with kubectl Port-Forward. If you require your monitoring interfaces to be publicly accessible over the internet, you can skip to the following section on completing a Prometheus Operator Deployment with HTTPS and Basic Auth.

Deploy Prometheus Operator

In this section, you will create a Helm chart values file and use it to deploy Prometheus Operator to your LKE cluster.

Using the text editor of your choice, create a file named values.yaml in the ~/lke-monitor directory and save it with the configurations below. Since the control plane is Linode-managed, as part of this step we will also disable metrics collection for the control plane component:

Caution
The below configuration will establish persistent data storage with three separate 10GiB Block Storage Volumes for Prometheus, Alertmanager, and Grafana. Because the Prometheus Operator deploys as StatefulSets, these Volumes and their associated Persistent Volume resources must be deleted manually if you later decide to tear down this Helm release.

~/lke-monitor/values.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
# Prometheus Operator Helm Chart values for Linode Kubernetes Engine minimal deployment
prometheus:
  prometheusSpec:
    storageSpec:
      volumeClaimTemplate:
        spec:
          storageClassName: linode-block-storage-retain
          resources:
            requests:
              storage: 10Gi

alertmanager:
  alertmanagerSpec:
    storage:
      volumeClaimTemplate:
        spec:
          storageClassName: linode-block-storage-retain
          resources:
            requests:
              storage: 10Gi

grafana:
  persistence:
    enabled: true
    storageClassName: linode-block-storage-retain
    size: 10Gi

# Disable metrics for Linode-managed Kubernetes control plane elements
kubeEtcd:
  enabled: false

kubeControllerManager:
  enabled: false

kubeScheduler:
  enabled: false
    

Export an environment variable to store your Grafana admin password:
Note
Replace prom-operator in the below command with a secure password and save the password for later reference.
```
export GRAFANA_ADMINPASSWORD="prom-operator"
```
Using Helm, deploy a Prometheus Operator release labeled lke-monitor in the monitoring namespace on your LKE cluster with the settings established in your values.yaml file:
```
helm install 
lke-monitor stable/prometheus-operator 
-f ~/lke-monitor/values.yaml 
--namespace monitoring 
--set grafana.adminPassword=$GRAFANA_ADMINPASSWORD 
--set prometheusOperator.createCustomResource=false
```
Note
You can safely ignore messages similar to manifest_sorter.go:192: info: skipping unknown hook: "crd-install" as discussed in this Github issues thread.
Alternatively, you can add --set prometheusOperator.createCustomResource=false to the above command to prevent the message from appearing.

Verify that the Prometheus Operator has been deployed to your LKE cluster and its components are running and ready by checking the pods in the monitoring namespace:

kubectl -n monitoring get pods

You should see a similar output to the following:

  
NAME                                                     READY   STATUS    RESTARTS   AGE
alertmanager-lke-monitor-prometheus-ope-alertmanager-0   2/2     Running   0          45s
lke-monitor-grafana-84cbb54f98-7gqtk                     2/2     Running   0          54s
lke-monitor-kube-state-metrics-68c56d976f-n587d          1/1     Running   0          54s
lke-monitor-prometheus-node-exporter-6xt8m               1/1     Running   0          53s
lke-monitor-prometheus-node-exporter-dkc27               1/1     Running   0          53s
lke-monitor-prometheus-node-exporter-pkc65               1/1     Running   0          53s
lke-monitor-prometheus-ope-operator-f87bc9f7c-w56sw      2/2     Running   0          54s
prometheus-lke-monitor-prometheus-ope-prometheus-0       3/3     Running   1          35s

Access Monitoring Interfaces with Port-Forward

List the services running in the monitoring namespace and review their respective ports:

kubectl -n monitoring get svc

You should see an output similar to the following:

  
NAME                                      TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)                     AGE
alertmanager-operated                     ClusterIP   None            <none>        9093/TCP,9094/TCP,9094/UDP  115s
lke-monitor-grafana                       ClusterIP   10.128.140.155  <none>        80/TCP                      2m3s
lke-monitor-kube-state-metrics            ClusterIP   10.128.165.34   <none>        8080/TCP                    2m3s
lke-monitor-prometheus-node-exporter      ClusterIP   10.128.192.213  <none>        9100/TCP                    2m3s
lke-monitor-prometheus-ope-alertmanager   ClusterIP   10.128.153.6    <none>        9093/TCP                    2m3s
lke-monitor-prometheus-ope-operator       ClusterIP   10.128.198.160  <none>        8080/TCP,443/TCP            2m3s
lke-monitor-prometheus-ope-prometheus     ClusterIP   10.128.121.47   <none>        9090/TCP                    2m3s
prometheus-operated                       ClusterIP   None            <none>        9090/TCP                    105s

From the above output, the resource services you will access have the corresponding ports:

Resource	Service Name	Port
Prometheus	lke‑monitor‑prometheus‑ope‑prometheus	9090
Alertmanager	lke‑monitor‑prometheus‑ope‑alertmanager	9093
Grafana	lke‑monitor‑grafana	80

Use kubectl port-forward to open a connection to a service, then access the service’s interface by entering the corresponding address in your web browser:
Note
Press control+C on your keyboard to terminate a port-forward process after entering any of the following commands.
- To provide access to the Prometheus interface at the address 127.0.0.1:9090 in your web browser, enter:
```
kubectl -n monitoring 
port-forward 
svc/lke-monitor-prometheus-ope-prometheus 
9090
```
- To provide access to the Alertmanager interface at the address 127.0.0.1:9093 in your web browser, enter:
```
kubectl -n monitoring 
port-forward 
svc/lke-monitor-prometheus-ope-alertmanager  
9093
```
- To provide access to the Grafana interface at the address 127.0.0.1:8081 in your web browser, enter:
```
kubectl -n monitoring 
port-forward 
svc/lke-monitor-grafana  
8081:80
```
  Log in with the username admin and the password you exported as $GRAFANA_ADMINPASSWORD. The Grafana dashboards are accessible at Dashboards > Manage from the left navigation bar.

Prometheus Operator Deployment with HTTPS and Basic Auth

Note
Before you start on this section, ensure that you have completed all of the steps in Before you Begin.

This section will show you how to install and configure the necessary components for secure, path-based, public access to the Prometheus, Alertmanager, and Grafana interfaces using the domain you have configured for use with Linode.

An Ingress is used to provide external routes, via HTTP or HTTPS, to your cluster’s services. An Ingress Controller, like the NGINX Ingress Controller, fulfills the requirements presented by the Ingress using a load balancer.

To enable HTTPS on your monitoring interfaces, you will create a Transport Layer Security (TLS) certificate from the Let’s Encrypt certificate authority (CA) using the ACME protocol. This will be facilitated by cert-manager, the native Kubernetes certificate management controller.

While the Grafana interface is natively password-protected, the Prometheus and Alertmanager interfaces must be secured by other means. This guide covers basic authentication configurations to secure the Prometheus and Alertmanager interfaces.

If you are completing this section of the guide after completing a Prometheus Operator Minimal Deployment, you can use Helm to upgrade your release and maintain the persistent data storage for your monitoring stack.

Install the NGINX Ingress Controller

In this section, you will install the NGINX Ingress Controller using Helm, which will create a NodeBalancer to handle your cluster’s traffic.

Install the Google stable NGINX Ingress Controller Helm chart:
```
helm install nginx-ingress stable/nginx-ingress
```

Access your NodeBalancer’s assigned external IP address.

kubectl -n default get svc -o wide nginx-ingress-controller

The command will return a similar output to the following:

  
NAME                       TYPE           CLUSTER-IP      EXTERNAL-IP    PORT(S)                      AGE   SELECTOR
nginx-ingress-controller   LoadBalancer   10.128.41.200   192.0.2.0      80:30889/TCP,443:32300/TCP   59s   app.kubernetes.io/component=controller,app=nginx-ingress,release=nginx-ingress

Copy the IP address of the EXTERNAL IP field and navigate to Linode’s DNS Manager and create an A record using this external IP address and a hostname value corresponding to the subdomain you plan to use with your domain.

Now that your NGINX Ingress Controller has been deployed and your domain’s A record has been updated, you are ready to enable HTTPS on your monitoring interfaces.

Install cert-manager

Note
Before performing the commands in this section, ensure that your DNS has had time to propagate across the internet. You can query the status of your DNS by using the following command, substituting example.com for your domain (including a subdomain if you have configured one).
dig +short example.com
If successful, the output should return the IP address of your NodeBalancer.

Install cert-manager’s CRDs.

kubectl apply --validate=false -f https://github.com/jetstack/cert-manager/releases/download/v0.15.2/cert-manager.crds.yaml

Add the Helm repository which contains the cert-manager Helm chart.
```
helm repo add jetstack https://charts.jetstack.io
```
Update your Helm repositories.
```
helm repo update
```
Install the cert-manager Helm chart. These basic configurations should be sufficient for many use cases, however, additional cert-manager configurable parameters can be found in cert-manager’s official documentation.
```
helm install 
cert-manager jetstack/cert-manager 
--namespace cert-manager 
--version v0.15.2
```

Verify that the corresponding cert-manager pods are running and ready.

kubectl -n cert-manager get pods

You should see a similar output:

  
NAME                                       READY   STATUS    RESTARTS   AGE
cert-manager-749df5b4f8-mc9nj              1/1     Running   0          19s
cert-manager-cainjector-67b7c65dff-4fkrw   1/1     Running   0          19s
cert-manager-webhook-7d5d8f856b-4nw9z      1/1     Running   0          19s

Create a ClusterIssuer Resource

Now that cert-manager is installed and running on your cluster, you will need to create a ClusterIssuer resource which defines which CA can create signed certificates when a certificate request is received. A ClusterIssuer is not a namespaced resource, so it can be used by more than one namespace.

Using the text editor of your choice, create a file named acme-issuer-prod.yaml with the example configurations, replacing the value of email with your own email address for the ACME challenge:

~/lke-monitor/acme-issuer-prod.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
apiVersion: cert-manager.io/v1alpha2
kind: ClusterIssuer
metadata:
  name: letsencrypt-prod
spec:
  acme:
    email: [email protected]
    server: https://acme-v02.api.letsencrypt.org/directory
    privateKeySecretRef:
      name: letsencrypt-secret-prod
    solvers:
    - http01:
        ingress:
          class: nginx
    

This manifest file creates a ClusterIssuer resource that will register an account on an ACME server. The value of spec.acme.server designates Let’s Encrypt’s production ACME server, which should be trusted by most browsers.
Note
Let’s Encrypt provides a staging ACME server that can be used to test issuing trusted certificates, while not worrying about hitting Let’s Encrypt’s production rate limits. The staging URL is https://acme-staging-v02.api.letsencrypt.org/directory.
The value of privateKeySecretRef.name provides the name of a secret containing the private key for this user’s ACME server account (this is tied to the email address you provide in the manifest file). The ACME server will use this key to identify you.
To ensure that you own the domain for which you will create a certificate, the ACME server will issue a challenge to a client. cert-manager provides two options for solving challenges, http01 and DNS01. In this example, the http01 challenge solver will be used and it is configured in the solvers array. cert-manager will spin up challenge solver Pods to solve the issued challenges and use Ingress resources to route the challenge to the appropriate Pod.

Create the ClusterIssuer resource:

kubectl apply -f ~/lke-monitor/acme-issuer-prod.yaml

Create a Certificate Resource

After you have a ClusterIssuer resource, you can create a Certificate resource. This will describe your x509 public key certificate and will be used to automatically generate a CertificateRequest which will be sent to your ClusterIssuer.

Using the text editor of your choice, create a file named certificate-prod.yaml with the example configurations:

Note
Replace the value of spec.dnsNames with the domain, including subdomains, that you will use to host your monitoring interfaces.

~/lke-monitor/certificate-prod.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
apiVersion: cert-manager.io/v1alpha2
kind: Certificate
metadata:
  name: prometheus-operator-prod
  namespace: monitoring
spec:
  secretName: letsencrypt-secret-prod
  duration: 2160h # 90d
  renewBefore: 360h # 15d
  issuerRef:
    name: letsencrypt-prod
    kind: ClusterIssuer
  dnsNames:
  - example.com
    

Note
The configurations in this example create a Certificate in the monitoring namespace that is valid for 90 days and renews 15 days before expiry.

Create the Certificate resource:

kubectl apply -f ~/lke-monitor/certificate-prod.yaml

Verify that the Certificate has been successfully issued:

kubectl -n monitoring get certs

When your certificate is ready, you should see a similar output:

  
NAME          READY   SECRET                    AGE
lke-monitor   True    letsencrypt-secret-prod   33s

Next, you will create the necessary resources for basic authentication of the Prometheus and Alertmanager interfaces.

Configure Basic Auth Credentials

In this section, you will use htpasswd to generate credentials for basic authentication and create a Kubernetes Secret, which will then be applied to your Ingress configuration to secure access to your monitoring interfaces.

Create a basic authentication password file for the user admin:
```
htpasswd -c ~/lke-monitor/auth admin
```
Follow the prompts to create a secure password, then store your password securely for future reference.
Create a Kubernetes Secret for the monitoring namespace using the file you created above:
```
kubectl -n monitoring create secret generic basic-auth --from-file=auth
```

Verify that the basic-auth secret has been created on your LKE cluster:

kubectl -n monitoring get secret basic-auth

You should see a similar output to the following:

  
NAME         TYPE     DATA   AGE
basic-auth   Opaque   1      81s

All the necessary components are now in place to be able to enable HTTPS on your monitoring interfaces. In the next section, you will complete the steps needed to deploy Prometheus Operator.

Deploy or Upgrade Prometheus Operator

In this section, you will create a Helm chart values file and use it to deploy Prometheus Operator to your LKE cluster.

Using the text editor of your choice, create a file named values-https-basic-auth.yaml in the ~/lke-monitor directory and save it with the configurations below. Since the control plane is Linode-managed, as part of this step we will also disable metrics collection for the control plane component:

Note

Caution
The below configuration will establish persistent data storage with three separate 10GiB Block Storage Volumes for Prometheus, Alertmanager, and Grafana. Because the Prometheus Operator deploys as StatefulSets, these Volumes and their associated Persistent Volume resources must be deleted manually if you later decide to tear down this Helm release.

~/lke-monitor/values-https-basic-auth.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
# Helm chart values for Prometheus Operator with HTTPS and basic auth
prometheus:
  ingress:
    enabled: true
    annotations:
      kubernetes.io/ingress.class: nginx
      nginx.ingress.kubernetes.io/rewrite-target: /$2
      cert-manager.io/cluster-issuer: letsencrypt-prod
      nginx.ingress.kubernetes.io/auth-type: basic
      nginx.ingress.kubernetes.io/auth-secret: basic-auth
      nginx.ingress.kubernetes.io/auth-realm: 'Authentication Required'
    hosts:
    - example.com
    paths:
    - /prometheus(/|$)(.*)
    tls:
    - secretName: lke-monitor-tls
      hosts:
      - example.com
  prometheusSpec:
    routePrefix: /
    externalUrl: https://example.com/prometheus
    storageSpec:
      volumeClaimTemplate:
        spec:
          storageClassName: linode-block-storage-retain
          resources:
            requests:
              storage: 10Gi

alertmanager:
  ingress:
    enabled: true
    annotations:
      kubernetes.io/ingress.class: nginx
      nginx.ingress.kubernetes.io/rewrite-target: /$2
      cert-manager.io/cluster-issuer: letsencrypt-prod
      nginx.ingress.kubernetes.io/auth-type: basic
      nginx.ingress.kubernetes.io/auth-secret: basic-auth
      nginx.ingress.kubernetes.io/auth-realm: 'Authentication Required'
    hosts:
    - example.com
    paths:
    - /alertmanager(/|$)(.*)
    tls:
    - secretName: lke-monitor-tls
      hosts:
      - example.com
  alertmanagerSpec:
    routePrefix: /
    externalUrl: https://example.com/alertmanager
    storage:
      volumeClaimTemplate:
        spec:
          storageClassName: linode-block-storage-retain
          resources:
            requests:
              storage: 10Gi

grafana:
  persistence:
    enabled: true
    storageClassName: linode-block-storage-retain
    size: 10Gi
  ingress:
    enabled: true
    annotations:
      kubernetes.io/ingress.class: nginx
      nginx.ingress.kubernetes.io/rewrite-target: /$2
      nginx.ingress.kubernetes.io/auth-type: basic
      nginx.ingress.kubernetes.io/auth-secret: basic-auth
      nginx.ingress.kubernetes.io/auth-realm: 'Authentication Required'
    hosts:
    - example.com
    path: /grafana(/|$)(.*)
    tls:
    - secretName: lke-monitor-tls
      hosts:
      - example.com
  grafana.ini:
    server:
      domain: example.com
      root_url: "%(protocol)s://%(domain)s/grafana/"
      enable_gzip: "true"

# Disable control plane metrics
kubeEtcd:
  enabled: false

kubeControllerManager:
  enabled: false

kubeScheduler:
  enabled: false
    

Export an environment variable to store your Grafana admin password:
Note
Replace prom-operator in the below command with a secure password and save the password for later reference.
```
export GRAFANA_ADMINPASSWORD="prom-operator"
```

Using Helm, deploy a Prometheus Operator release labeled lke-monitor in the monitoring namespace on your LKE cluster with the settings established in your values-https-basic-auth.yaml file:

Note
If you have already deployed a Prometheus Operator release, you can upgrade it by replacing helm install with helm upgrade in the below command.

helm install 
lke-monitor stable/prometheus-operator 
-f ~/lke-monitor/values-https-basic-auth.yaml 
--namespace monitoring 
--set grafana.adminPassword=$GRAFANA_ADMINPASSWORD

Once completed, you will see output similar to the following:

  
NAME: lke-monitor
LAST DEPLOYED: Mon Jul 27 17:03:46 2020
NAMESPACE: monitoring
STATUS: deployed
REVISION: 1
NOTES:
The Prometheus Operator has been installed. Check its status by running:
  kubectl --namespace monitoring get pods -l "release=lke-monitor"

Visit https://github.com/coreos/prometheus-operator for instructions on how
to create & configure Alertmanager and Prometheus instances using the Operator.

Verify that the Prometheus Operator has been deployed to your LKE cluster and its components are running and ready by checking the pods in the monitoring namespace:

kubectl -n monitoring get pods

You should see a similar output to the following, confirming that you are ready to access your monitoring interfaces using your domain:

  
NAME                                                     READY   STATUS    RESTARTS   AGE
alertmanager-lke-monitor-prometheus-ope-alertmanager-0   2/2     Running   0          45s
lke-monitor-grafana-84cbb54f98-7gqtk                     2/2     Running   0          54s
lke-monitor-kube-state-metrics-68c56d976f-n587d          1/1     Running   0          54s
lke-monitor-prometheus-node-exporter-6xt8m               1/1     Running   0          53s
lke-monitor-prometheus-node-exporter-dkc27               1/1     Running   0          53s
lke-monitor-prometheus-node-exporter-pkc65               1/1     Running   0          53s
lke-monitor-prometheus-ope-operator-f87bc9f7c-w56sw      2/2     Running   0          54s
prometheus-lke-monitor-prometheus-ope-prometheus-0       3/3     Running   1          35s

Access Monitoring Interfaces from your Domain

Your monitoring interfaces are now publicly accessible with HTTPS and basic auth from the domain you have configured for use with this guide at the following paths:

Resource	Domain and path
Prometheus	example.com/prometheus
Alertmanager	example.com/alertmanager
Grafana	example.com/grafana

When accessing an interface for the first time, log in as admin with the password you configured for basic auth credentials.

When accessing the Grafana interface, you will then log in again as admin with the password you exported as $GRAFANA_ADMINPASSWORD on your local environment. The Grafana dashboards are accessible at Dashboards > Manage from the left navigation bar.

More Information

You may wish to consult the following resources for additional information on this topic. While these are provided in the hope that they will be useful, please note that we cannot vouch for the accuracy or timeliness of externally hosted materials.

This guide is published under a CC BY-ND 4.0 license.

Source link

Installieren und Sichern von Grafana unter Ubuntu 20.04

Der Autor hat den COVID-19 Relief Fund dazu ausgewählt, eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

Einführung

Grafana ist ein Open-Source-basiertes Visualisierungs- und Überwachungstool für Daten, das sich mit komplexen Daten aus Quellen wie Prometheus, InfluxDB, Graphite und ElasticSearch integrieren lässt. Mit Grafana können Sie Warnungen, Benachrichtigungen und Ad-hoc-Filter für Ihre Daten erstellen und durch integrierte Freigabefunktionen die Zusammenarbeit mit Teamkollegen erleichtern.

In diesem Tutorial installieren Sie Grafana und sichern die Anwendung mit einem SSL-Zertifikat und einem Nginx-Reverseproxy. Nach der Einrichtung von Grafana haben Sie die Möglichkeit, Benutzerauthentifizierung über GitHub zu konfigurieren, um die Berechtigungen Ihres Teams besser zu organisieren.

Voraussetzungen

Um dieser Anleitung zu folgen, benötigen Sie:

Zwei Ubuntu 20.04-Server, die gemäß des Leitfadens zur Ersteinrichtung des Servers für Ubuntu 20.04 eingerichtet wurde, einschließlich eines non-root users, der über sudo-Berechtigungen verfügt, und einer mit ufw konfigurierten Firewall.
Einen vollständig registrierten Domänennamen. In diesem Tutorial wird durchgehend your_domain verwendet. Sie können einen Domänennamen unter Namecheap günstig erwerben oder einen kostenlosen von Freenom herunterladen oder einfach die Domänenregistrierungsstelle Ihrer Wahl verwenden.
Richten Sie die folgenden DNS-Einträge für Ihren Server ein. Sie können Einrichten eines Hostnamens mit DigitalOcean konsultieren, um mehr über das Hinzufügen von Hostnamen zu erfahren.
- Einen A-Datensatz mit your-domain, der auf die öffentliche IP-Adresse Ihres Servers verweist.
- Einen A-Eintrag mit www.your_domain, der auf die öffentliche IP-Adresse Ihres Servers verweist.
Nginx, eingerichtet anhand des Tutorials zum Installieren von Nginx unter Ubuntu 20.04, einschließlich eines Serverblocks für Ihre Domäne.
Einen Nginx-Serverblock mit konfiguriertem Let’s Encrypt; folgen Sie zum Einrichten dieser Komponente Sichern von Nginx mit Let’s Encrypt unter Ubuntu 20.04.
Optional benötigen Sie zur Einrichtung der GitHub-Authentifizierung ein GitHub-Konto, das mit einer Organisation verknüpft ist.

Schritt 1 — Installieren von Grafana

In diesem ersten Schritt installieren Sie Grafana auf Ihrem Ubuntu 20.04-Server. Sie können Grafana installieren, indem Sie entweder die Anwendung direkt von der offiziellen Website herunterladen oder ein APT-Repository verwenden. Da ein APT-Repository die Installation und Verwaltung von Grafana-Updates erleichtert, wenden wir in diesem Tutorial diese Methode an.

Laden Sie mit wget den GPG-Schlüssel von Grafana herunter und übergeben Sie dann die Ausgabe an apt-key. Dadurch wird der Schlüssel zur Liste der vertrauenswürdigen Schlüssel Ihrer APT-Installation hinzugefügt. Nun können Sie das GPG-signierte Grafana-Paket herunterladen und verifizieren:

wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -

In diesem Befehl deaktiviert die Option -q die Nachricht zur Statusaktualisierung für wget, während -O die Datei ausgibt, die Sie in das Terminal heruntergeladen haben. Diese beiden Optionen sorgen dafür, dass nur die Inhalte der heruntergeladenen Datei an apt-key übertragen werden.

Fügen Sie als Nächstes das Grafana-Repository zu Ihren APT-Quellen hinzu:

sudo add-apt-repository "deb https://packages.grafana.com/oss/deb stable main"

Aktualisieren Sie dann den APT-Cache, um Ihre Paketlisten zu aktualisieren:

Sie können nun mit der Installation fortfahren:

Sobald Grafana installiert ist, verwenden Sie systemctl, um den Grafana-Server zu starten:

sudo systemctl start grafana-server

Überprüfen Sie als Nächstes, ob Grafana ausgeführt wird, indem Sie den Status des Diensts prüfen:

sudo systemctl status grafana-server

Sie erhalten eine ähnliche Ausgabe wie diese:

Output● grafana-server.service - Grafana instance
     Loaded: loaded (/lib/systemd/system/grafana-server.service; disabled; vendor preset: enabled)
   Active: active (running) since Thu 2020-05-21 08:08:10 UTC; 4s ago
     Docs: http://docs.grafana.org
 Main PID: 15982 (grafana-server)
    Tasks: 7 (limit: 1137)
...

Diese Ausgabe enthält Informationen über den Prozess von Grafana, einschließlich seines Status, Main Process Identifier (PID) und mehr. active (running) bedeutet, dass der Prozess richtig ausgeführt wird.

Abschließend aktivieren Sie den Dienst, damit Grafana beim Booten automatisch gestartet wird:

sudo systemctl enable grafana-server

Sie erhalten die folgende Ausgabe:

OutputSynchronizing state of grafana-server.service with SysV service script with /lib/systemd/systemd-sysv-install.
Executing: /lib/systemd/systemd-sysv-install enable grafana-server
Created symlink /etc/systemd/system/multi-user.target.wants/grafana-server.service → /usr/lib/systemd/system/grafana-server.service.

Dadurch wird bestätigt, dass systemd die erforderlichen symbolischen Links für den Autostart von Grafana erstellt hat.

Grafana ist nun installiert und einsatzbereit. Als Nächstes sichern Sie Ihre Verbindung zu Grafana mit einem Reverseproxy und SSL-Zertifikat.

`Schritt 2 — Einrichten des Reverseproxy`

Durch Verwendung eines SSL-Zertifikats wird sichergestellt, dass Ihre Daten sicher sind, indem die Verbindung zu und von Grafana verschlüsselt wird. Um diese Verbindung nutzen zu können, müssen Sie jedoch zunächst Nginx als Reverseproxy für Grafana neu konfigurieren.

Öffnen Sie die Nginx-Konfigurationsdatei, die Sie beim Einrichten des Nginx-Serverblocks mit Let’s Encrypt in den Voraussetzungen erstellt haben. Sie können einen beliebigen Texteditor verwenden, für dieses Tutorial nutzen wir allerdings nano:

sudo nano /etc/nginx/sites-available/your_domain

Suchen Sie nach dem folgenden Block:

/etc/nginx/sites-available/your_domain

...
    location / {
        try_files $uri $uri/ =404;
    }
...

Da Sie Nginx bereits für Kommunikation über SSL konfiguriert haben und der gesamte Webverkehr auf Ihrem Server schon über Nginx läuft, müssen Sie Nginx nur noch dazu anweisen, alle Anfragen an Grafana (standardmäßig an Port 3000) weiterzuleiten.

Löschen Sie in diesem location block die vorhandene Zeile try_files und ersetzen Sie sie durch die folgende Option proxy_pass:

/etc/nginx/sites-available/your_domain

...
    location / {
        proxy_pass http://localhost:3000;
    }
...

Dadurch wird der Proxy dem entsprechenden Port zugeordnet. Sobald Sie damit fertig sind, speichern und schließen Sie die Datei, indem Sie STRG+X, Y und dann die Eingabetaste drücken (wenn Sie nano verwenden).

Testen Sie nun die neuen Einstellungen, um sich zu vergewissern, dass alles korrekt konfiguriert wurde:

Sie erhalten die folgende Ausgabe:

Outputnginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Aktivieren Sie schließlich die Änderungen, indem Sie Nginx neu laden:

sudo systemctl reload nginx

Sie können nun das Standardanmeldefenster von Grafana aufrufen, indem Sie in Ihren Webbrowser https://your_domain eingeben. Wenn Grafana nicht erreichbar ist, prüfen Sie, ob Ihre Firewall so eingerichtet ist, dass Datenverkehr an Port 443 zugelassen wird, und befolgen Sie dann erneut die vorherigen Anweisungen.

Nachdem Sie die Verbindung zu Grafana verschlüsselt haben, können Sie nun zusätzliche Sicherheitsmaßnahmen implementieren, angefangen beim Ändern der standardmäßigen Anmeldedaten für den Grafana-Administrator.

`Schritt 3 — Aktualisieren von Anmeldedaten`

Da jede Grafana-Installation standardmäßig dieselben Administrator-Anmeldedaten nutzt, sollten Sie die Anmeldedaten so schnell wie möglich ändern. In diesem Schritt aktualisieren Sie die Anmeldedaten zur Verbesserung der Sicherheit.

Navigieren Sie zunächst über Ihren Webbrowser zu https://your_domain. Dadurch wird das standardmäßige Anmeldefenster mit folgenden Elementen angezeigt: einem Formular, das Sie dazu auffordert, eine E-Mail-Adresse oder Benutzername und ein Passwort einzugeben, einer Schaltfläche zum Anmelden sowie einem Link namens Passwort vergessen? .

Geben Sie admin sowohl in das Feld E-Mail-Adresse oder Benutzername und Passwort ein und klicken Sie dann auf die Schaltfläche Anmelden.

Im nächsten Fenster werden Sie aufgefordert, die Sicherheit Ihres Kontos zu erhöhen, indem Sie das Standardpasswort ändern:

Geben Sie das Passwort, das Sie verwenden möchten, in die Felder Neues Passwort und Neues Passwort bestätigen ein.

Jetzt können Sie auf Übermitteln klicken, um die neuen Daten zu speichern, oder auf Überspringen, um diesen Schritt zu überspringen. Wenn Sie den Schritt überspringen, werden Sie dazu aufgefordert, das Passwort bei der nächsten Anmeldung zu ändern.

Um die Sicherheit Ihrer Grafana-Konfiguration zu erhöhen, klicken Sie auf Übermitteln. Sie gelangen zum Dashboard Willkommen bei Grafana:

Sie haben Ihr Konto sicherer gemacht, indem Sie die Standardanmeldedaten geändert haben. Als Nächstes werden Sie Änderungen an Ihrer Grafana-Konfiguration vornehmen, damit ohne Ihre Genehmigung niemand ein neues Grafana-Konto erstellen kann.

`Schritt 4 — Deaktivieren von Grafana-Registrierungen und anonymem Zugriff`

Grafana bietet Optionen, mit denen Besucher für sich selbst Benutzerkonten erstellen und eine Vorschau von Dashboards anzeigen können, ohne sich registrieren zu müssen. Wenn Grafana nicht über das Internet zugänglich ist oder mit öffentlich verfügbaren Daten wie Dienststatus arbeitet, können Sie diese Funktionen ggf. zulassen. Wenn Sie Grafana jedoch online verwenden, um mit sensiblen Daten zu arbeiten, kann anonymer Zugriff ein Sicherheitsproblem darstellen. Um dieses Problem zu beheben, nehmen Sie einige Änderungen an Ihrer Grafana-Konfiguration vor.

Öffnen Sie zunächst die Hauptkonfigurationsdatei von Grafana zur Bearbeitung:

sudo nano /etc/grafana/grafana.ini

Suchen Sie die folgende Direktive allow_sign_up unter der Überschrift [users]:

/etc/grafana/grafana.ini

...
[users]
# disable user signup / registration
;allow_sign_up = true
...

Wenn Sie diese Direktive mit true aktivieren, wird dem Anmeldefenster eine Schaltfläche zum Anmelden hinzugefügt, damit sich Benutzer registrieren und auf Grafana zugreifen können.

Durch Deaktivieren dieser Direktive mit false wird die Schaltfläche zum Anmelden entfernt, was die Sicherheit und den Datenschutz von Grafana erhöht.

Heben Sie die Kommentierung dieser Direktive auf, indem Sie das ;-Zeichen am Anfang der Zeile entfernen und dann die Option auf false setzen:

/etc/grafana/grafana.ini

...
[users]
# disable user signup / registration
allow_sign_up = false
...

Als Nächstes suchen Sie nach der folgenden aktivierten Direktive unter der Überschrift [auth.anonymous]:

/etc/grafana/grafana.ini

...
[auth.anonymous]
# enable anonymous access
;enabled = false
...

Wenn Sie enabled auf true setzen, erhalten nicht registrierte Benutzer Zugriff auf Ihre Dashboards; wenn Sie die Option auf false setzen, wird der Zugriff auf das Dashboard auf registrierte Benutzer beschränkt.

Heben Sie die Kommentierung dieser Direktive auf, indem Sie das ;-Zeichen am Anfang der Zeile entfernen und die Option dann auf false setzen:

/etc/grafana/grafana.ini

...
[auth.anonymous]
# enable anonymous access
enabled = false
...

Speichern Sie die Datei und beenden Sie den Texteditor.

Um die Änderungen zu aktivieren, starten Sie Grafana neu:

sudo systemctl restart grafana-server

Vergewissern Sie sich, ob alles funktioniert, indem Sie den Dienststatus von Grafana überprüfen:

sudo systemctl status grafana-server

Wie zuvor wird die Ausgabe melden, dass Grafana active (running) ist.

Rufen Sie nun https://your_domain in Ihrem Webbrowser auf. Um zum Fenster zum Anmelden zurückzukehren, bewegen Sie den Cursor links unten im Bildschirm zu Ihrem Avatar und klicken Sie auf die Option Abmelden, die angezeigt wird.

Vergewissern Sie sich nach dem Abmelden, dass es keine Schaltfläche zum Anmelden gibt und Sie sich nicht anmelden können, ohne Anmeldedaten einzugeben.

Nun ist Grafana vollständig konfiguriert und einsatzbereit. Als Nächstes können Sie den Anmeldeprozess für Ihre Organisation vereinfachen, indem Sie über GitHub authentifizieren.

`(Optional) Schritt 5 — Einrichten einer GitHub OAuth-Anwendung`

Für einen alternativen Ansatz zur Anmeldung können Sie Grafana für eine Authentifizierung über GitHub konfigurieren, womit allen Mitgliedern autorisierter GitHub-Organisationen Zugriff gewährt wird. Dies kann besonders nützlich sein, wenn Sie möchten, dass verschiedene Entwickler zusammenarbeiten und Metriken aufrufen können, ohne spezielle Anmeldedaten für Grafana erstellen zu müssen.

Melden Sie sich zunächst bei einem GitHub-Konto, das mit Ihrer Organisation verknüpft ist, an und navigieren Sie dann zu Ihrer GitHub-Profilseite unter https://github.com/settings/profile.

Wechseln Sie den Einstellungskontext, indem Sie auf der linken Seite des Bildschirms auf Ihren Namen klicken und dann im Dropdown-Menü Ihre Organisation auswählen. Dadurch wird der Kontext von Persönliche Einstellungen in Organisationseinstellungen geändert.

Im nächsten Bildschirm sehen Sie Ihr Organisationsprofil, in dem Sie Einstellungen wie den Anzeigenamen der Organisation, die E-Mail-Adresse der Organisation und die URL der Organisation ändern können.

Da Grafana OAuth, einen offenen Standard zum Gewähren von Zugriff auf lokale Ressourcen an andere Remotebenutzer und Authentifizieren von Benutzern über GitHub nutzt, müssen Sie innerhalb von GitHub eine neue OAuth-Anwendung erstellen.

Klicken Sie auf den Link OAuth-Anwendungen unter Entwicklereinstellungen unten links im Bildschirm.

Wenn Sie in GitHub nicht bereits über OAuth-Anwendungen verfügen, die mit Ihrer Organisation verknüpft sind, erhalten Sie den Hinweis, dass keine Anwendungen im Besitz der Organisation sind. Andernfalls sehen Sie eine Liste der OAuth-Anwendungen, die bereits mit Ihrem Konto verknüpft sind.

Klicken Sie auf die Schaltfläche Neue OAuth-Anwendung, um fortzufahren.

Geben Sie im nächsten Bildschirm folgende Details zu Ihrer Grafana-Installation ein:

Anwendungsname: Damit können Sie Ihre verschiedenen OAuth-Anwendungen voneinander unterscheiden.
URL der Homepage: Dadurch erfährt GitHub, wo sich Grafana befindet. Geben Sie in dieses Feld https://your_domain ein, wobei Sie your_domain durch Ihre Domäne ersetzen.
Anwendungsbeschreibung: Damit wird eine Beschreibung des Zwecks Ihrer OAuth-Anwendung angegeben.
Callback-URL für Anwendung: Das ist die Adresse, an die Benutzer nach der erfolgreichen Authentifizierung weitergeleitet werden. Für Grafana muss dieses Feld https://your_domain/login/github lauten.

Denken Sie daran, dass Grafana-Benutzer, die sich über GitHub anmelden, die Werte sehen, die Sie in den ersten drei vorangehenden Feldern eingegeben haben; geben Sie also sinnvolle und passende Werte ein.

Am Ende wird das Formular in etwa so aussehen:

Klicken Sie auf die grüne Schaltfläche Anwendung registrieren.

Sie werden nun auf eine Seite weitergeleitet, die die Client-ID und das Clientgeheimnis enthält, die mit Ihrer neuen OAuth-Anwendung verknüpft sind. Notieren Sie sich beide Werte, da Sie sie der Hauptkonfigurationsdatei von Grafana hinzufügen müssen, um die Einrichtung abzuschließen.

Achtung: Bewahren Sie Ihre Client-ID und das Clientgeheimnis an einem sicheren, nicht öffentlichen Ort auf, da diese Daten als Grundlage für Angriffe dienen können.

Nach der Erstellung Ihrer GitHub OAuth-Anwendung können Sie Grafana nun neu konfigurieren, sodass GitHub zur Authentifizierung genutzt wird.

`(Optional) Schritt 6 — Konfigurieren von Grafana als GitHub OAuth-Anwendung`

Um die GitHub-Authentifizierung für Ihr Grafana-Setup zu abzuschließen, werden Sie nun einige Änderungen an Ihren Grafana-Konfigurationsdateien vornehmen.

Öffnen Sie zunächst die Grafana-Hauptkonfigurationsdatei.

sudo nano /etc/grafana/grafana.ini

Suchen Sie die Überschrift [auth.github] und heben Sie die Kommentierung dieses Abschnitts auf, indem Sie das ;-Zeichen am Anfang der einzelnen Zeilen entfernen (außer bei ;allowed_domains = und ;team_ids=, die in diesem Tutorial nicht geändert werden).

Nehmen Sie als Nächstes folgende Änderungen vor:

Setzen Sie enabled und allow_sign_up auf true. Dadurch wird die GitHub-Authentifizierung aktiviert und Mitglieder der zugelassenen Organisation können Konten selbst erstellen. Beachten Sie, dass sich diese Einstellung von der Eigenschaft allow_sign_up unter [users] unterscheidet, die Sie in Schritt 4 geändert haben.
Setzen Sie client_id und client_secret auf die Werte, die Sie beim Erstellen Ihrer GitHub OAuth-Anwendung erhalten haben.
Verwenden Sie für allowed_organizations den Namen Ihrer Organisation, damit sich nur Mitglieder Ihrer Organisation bei Grafana registrieren und anmelden können.

Die vollständige Konfiguration wird wie folgt aussehen:

/etc/grafana/grafana.ini

...
[auth.github]
enabled = true
allow_sign_up = true
client_id = your_client_id_from_github
client_secret = your_client_secret_from_github
scopes = user:email,read:org
auth_url = https://github.com/login/oauth/authorize
token_url = https://github.com/login/oauth/access_token
api_url = https://api.github.com/user
;allowed_domains =
;team_ids =
allowed_organizations = your_organization_name
...

Sie haben Grafana nun alles gesagt, was die Anwendung über GitHub wissen muss. Zum Abschließen der Einrichtung müssen Sie Umleitungen hinter einem Reverseproxy aktivieren. Dazu wird ein Wert root_url unter der Überschrift [server] festgelegt.

/etc/grafana/grafana.ini

...
[server]
root_url = https://your_domain
...

Speichern Sie Ihre Konfiguration und schließen Sie die Datei.

Starten Sie Grafana anschließend neu, um die Änderungen zu aktivieren:

sudo systemctl restart grafana-server

Vergewissern Sie sich abschließend, dass der Dienst ausgeführt wird.

sudo systemctl status grafana-server

Die Ausgabe wird anzeigen, dass der Dienst active (running) ist.

Testen Sie Ihr neues Authentifizierungssystem nun durch Navigieren zu https://your_domain. Wenn Sie bereits bei Grafana angemeldet sind, fahren Sie mit der Maus über das Avatar-Logo in der linken unteren Ecke des Bildschirms und klicken Sie im zweiten Menü, das neben Ihrem Namen erscheint, auf Abmelden.

Auf der Anmeldeseite sehen Sie unter der ursprünglichen Schaltfläche zum Anmelden einen neuen Bereich, der eine Schaltfläche zum Anmelden mit GitHub inklusive des GitHub-Logos enthält.

Klicken Sie auf die Schaltfläche Anmelden mit GitHub, um an GitHub weitergeleitet zu werden, wo Sie sich bei Ihrem GitHub-Konto anmelden und Ihre Absicht zum Autorisieren von Grafana bestätigen können.

Klicken Sie auf die grüne Schaltfläche your_github_organization autorisieren.

Anmerkung: Stellen Sie sicher, dass Ihr GitHub-Konto Mitglied Ihrer zugelassenen Organisation ist und Ihre Grafana-E-Mail-Adresse mit Ihrer GitHub-E-Mail-Adresse übereinstimmt. Wenn Sie versuchen, sich bei einem GitHub-Konto zu authentifizieren, das kein Mitglied Ihrer zugelassenen Organisation ist, erhalten Sie eine Meldung zu Anmeldung fehlgeschlagen, in der Ihnen Folgendes mitgeteilt wird: Benutzer kein Mitglied einer der erforderlichen Organisationen.

Sie werden nun mit Ihrem vorhandenen Grafana-Konto angemeldet. Wenn für den Benutzer, als der Sie sich angemeldet haben, noch kein Grafana-Konto vorhanden ist, wird Grafana ein neues Benutzerkonto mit Viewer-Berechtigungen erstellen, damit neue Anwender ausschließlich vorhandene Dashboards verwenden können.

Um die Standardberechtigungen für neue Benutzer zu ändern, öffnen Sie die Hauptkonfigurationsdatei von Grafana zur Bearbeitung.

sudo nano /etc/grafana/grafana.ini

Suchen Sie die Direktive auto_assign_org_role unter der Überschrift [users] und heben Sie die Kommentierung der Einstellung auf, indem Sie das ;-Zeichen am Anfang der Zeile entfernen.

Setzen Sie die Direktive auf einen der folgenden Werte:

Viewer — kann nur vorhandene Dashboards verwenden
Editor — kann Dashboards verwenden, ändern und hinzufügen
Admin — kann alles tun

In diesem Tutorial wird die automatische Zuordnung auf Viewer gesetzt:

/etc/grafana/grafana.ini

...
[users]
...
auto_assign_org_role = Viewer
...

Sobald Sie Ihre Änderungen gespeichert haben, schließen Sie die Datei und starten Sie Grafana neu:

sudo systemctl restart grafana-server

Überprüfen Sie den Status des Diensts:

sudo systemctl status grafana-server

Wie zuvor wird der Status active (running) lauten.

Nun haben Sie Grafana so konfiguriert, dass Mitglieder Ihrer GitHub-Organisation Ihre Grafana-Installation registrieren und verwenden können.

`Zusammenfassung`

In diesem Tutorial haben Sie Grafana installiert, konfiguriert und gesichert und außerdem erfahren, wie sich Mitglieder Ihrer Organisation über GitHub authentifizieren können.

Um Ihre aktuelle Grafana-Installation zu erweitern, konsultieren Sie die Liste der offiziellen und von der Community entwickelten Dashboards und Plugins. Um mehr über die allgemeine Verwendung von Grafana zu erfahren, konsultieren Sie die offizielle Grafana-Dokumentation oder unsere anderen Überwachungsleitfäden.

Source link

1
2
3
4
Next Page »

Shared

Cloud VPS

Dedicated

Grafana

Using Grafana Loki with Object Storage

How to Deploy Prometheus Operator and Grafana on Linode Kubernetes Engine

The Prometheus Operator Monitoring Stack

Before You Begin

Prometheus Operator Minimal Deployment

Deploy Prometheus Operator

Access Monitoring Interfaces with Port-Forward

Prometheus Operator Deployment with HTTPS and Basic Auth

Install the NGINX Ingress Controller

Install cert-manager

Create a ClusterIssuer Resource

Create a Certificate Resource

Configure Basic Auth Credentials

Deploy or Upgrade Prometheus Operator

Access Monitoring Interfaces from your Domain

More Information

Installieren und Sichern von Grafana unter Ubuntu 20.04

Einführung

Voraussetzungen

Schritt 1 — Installieren von Grafana

Schritt 2 — Einrichten des Reverseproxy

Schritt 3 — Aktualisieren von Anmeldedaten

Schritt 4 — Deaktivieren von Grafana-Registrierungen und anonymem Zugriff

(Optional) Schritt 5 — Einrichten einer GitHub OAuth-Anwendung

(Optional) Schritt 6 — Konfigurieren von Grafana als GitHub OAuth-Anwendung

Zusammenfassung

`Schritt 2 — Einrichten des Reverseproxy`

`Schritt 3 — Aktualisieren von Anmeldedaten`

`Schritt 4 — Deaktivieren von Grafana-Registrierungen und anonymem Zugriff`

`(Optional) Schritt 5 — Einrichten einer GitHub OAuth-Anwendung`

`(Optional) Schritt 6 — Konfigurieren von Grafana als GitHub OAuth-Anwendung`

`Zusammenfassung`