Integrieren in eine Kubernetes-Bereitstellung mit Helm

In Kubernetes gehostete Anwendungen können mithilfe der App Configuration-Anbieterbibliothek auf Daten in App Configuration zugreifen. Der App Configuration-Anbieter verfügt über integrierte Zwischenspeicherungs- und Aktualisierungsfunktionen, sodass für Anwendungen eine dynamische Konfiguration ohne erneute Bereitstellung verwendet werden kann. Wenn Sie Ihre Anwendung lieber nicht aktualisieren möchten, zeigt dieses Tutorial, wie Sie Daten aus App Configuration mithilfe von Helm über die Bereitstellung in Ihre Kubernetes-Instanz übertragen. Auf diese Weise kann Ihre Anwendung weiterhin auf die Konfiguration von Kubernetes-Variablen und -Geheimnissen zugreifen. Sie führen ein Helm-Upgrade aus, wenn Ihre Anwendung neue Konfigurationsänderungen erfassen soll.

Tipp

Unter den Optionen für Workloads, die in Kubernetes gehostet werden, können Sie auf Azure App Configuration zugreifen.

Helm ermöglicht das Definieren, Installieren und Upgraden von in Kubernetes ausgeführten Anwendungen. Ein Helm-Chart enthält die Informationen, die zum Erstellen einer Instanz einer Kubernetes-Anwendung erforderlich sind. Die Konfiguration wird außerhalb des Charts in einer Datei namens values.yaml gespeichert.

Im Rahmen des Releaseprozesses wird das Chart von Helm mit der passenden Konfiguration zusammengeführt, um die Anwendung auszuführen. So können beispielsweise in values.yaml definierte Variablen als Umgebungsvariablen innerhalb der ausgeführten Container referenziert werden. Helm unterstützt auch die Erstellung von Kubernetes-Geheimnissen. Diese können als Datenvolumes eingebunden oder als Umgebungsvariablen verfügbar gemacht werden.

Sie können die in values.yaml gespeicherten Werte überschreiben, indem Sie beim Ausführen von Helm zusätzliche YAML-basierte Konfigurationsdateien über die Befehlszeile angeben. Azure App Configuration unterstützt das Exportieren von Konfigurationswerten in YAML-Dateien. Durch die Integration dieser Exportfunktion in Ihre Bereitstellung können von Ihren Kubernetes-Anwendungen in App Configuration gespeicherte Konfigurationswerte genutzt werden.

In diesem Tutorial lernen Sie Folgendes:

• Verwenden von Werten aus App Configuration beim Bereitstellen einer Anwendung in Kubernetes mit Helm
• Erstellen eines Kubernetes-Geheimnisses auf der Grundlage eines Key Vault-Verweises in App Configuration

In diesem Tutorial werden Grundkenntnisse im Zusammenhang mit der Verwaltung von Kubernetes mit Helm vorausgesetzt. Weitere Informationen zum Installieren von Anwendungen mit Helm in Azure Kubernetes Service finden Sie hier.

Voraussetzungen

• Ein Azure-Konto mit einem aktiven Abonnement. Erstellen Sie ein kostenloses Konto.
• Installieren Sie die Azure-Befehlszeilenschnittstelle (Version 2.4.0 oder höher).
• Installieren Sie Helm (Version 2.14.0 oder höher).
• Ein App Configuration-Speicher. Erstellen Sie einen Speicher.
• Ein Kubernetes-Cluster.

Schlüsselwerte hinzufügen

Fügen Sie dem App Configuration-Speicher die folgenden Schlüsselwerte hinzu, und belassen Sie Bezeichnung und Inhaltstyp bei ihren Standardwerten. Weitere Informationen zum Hinzufügen von Schlüssel-Wert-Paaren zu einem Speicher mithilfe des Azure-Portals oder der CLI finden Sie unter Erstellen eines Schlüssel-Wert-Paars.

Schlüssel	Wert
settings.color	Weiß
settings.message	Daten aus Azure App Configuration

Hinzufügen eines Key Vault-Verweises zu App Configuration

1. Melden Sie sich beim Azure-Portal an, und fügen Sie Key Vault ein Geheimnis mit dem Namen Password und dem Wert myPassword hinzu.

2. Wählen Sie die Instanz des App Configuration-Speichers aus, die Sie im vorherigen Abschnitt erstellt haben.

3. Wählen Sie Konfigurations-Explorer aus.

4. Wählen Sie + Erstellen>Schlüsseltresorverweis aus, und geben Sie dann die folgenden Werte an:

   • Schlüssel: Wählen Sie secrets.password aus.
   • Bezeichnung: Lassen Sie diesen Wert leer.
   • Abonnement, Ressourcengruppe und Schlüsseltresor: Geben Sie die Werte ein, die den Werten des im vorherigen Schritt erstellten Schlüsseltresors entsprechen.
   • Geheimnis: Wählen Sie das Geheimnis mit dem Namen Password aus, das Sie im vorherigen Abschnitt erstellt haben.

Erstellen des Helm-Charts

Erstellen Sie zunächst mithilfe des folgenden Befehls ein exemplarisches Helm-Chart:

helm create mychart

Von Helm wird ein neues Verzeichnis mit dem Namen „mychart“ und der unten gezeigten Struktur erstellt.

Tipp

Weitere Informationen finden Sie in diesem Chartleitfaden.

mychart
|-- Chart.yaml
|-- charts
|-- templates
|   |-- NOTES.txt
|   |-- _helpers.tpl
|   |-- deployment.yaml
|   |-- ingress.yaml
|   `-- service.yaml
`-- values.yaml

Aktualisieren Sie als Nächstes den Abschnitt spec:template:spec:containers der Datei deployment.yaml. Im folgenden Codeausschnitt werden dem Container zwei Umgebungsvariablen hinzugefügt. Die zugehörigen Werte werden zur Bereitstellungszeit dynamisch festgelegt.

env:
- name: Color
    value: {{ .Values.settings.color }}
- name: Message
    value: {{ .Values.settings.message }}

Nach der Aktualisierung sollte die Datei deployment.yaml wie folgt aussehen:

apiVersion: apps/v1beta2
kind: Deployment
metadata:
  name: {{ include "mychart.fullname" . }}
  labels:
    app.kubernetes.io/name: {{ include "mychart.name" . }}
    helm.sh/chart: {{ include "mychart.chart" . }}
    app.kubernetes.io/instance: {{ .Release.Name }}
    app.kubernetes.io/managed-by: {{ .Release.Service }}
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      app.kubernetes.io/name: {{ include "mychart.name" . }}
      app.kubernetes.io/instance: {{ .Release.Name }}
  template:
    metadata:
      labels:
        app.kubernetes.io/name: {{ include "mychart.name" . }}
        app.kubernetes.io/instance: {{ .Release.Name }}
    spec:
      containers:
        - name: {{ .Chart.Name }}
          image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
          imagePullPolicy: {{ .Values.image.pullPolicy }}
          env:
            - name: Color
              value: {{ .Values.settings.color }}
            - name: Message
              value: {{ .Values.settings.message }}
          ports:
            - name: http
              containerPort: 80
              protocol: TCP
          livenessProbe:
            httpGet:
              path: /
              port: http
          readinessProbe:
            httpGet:
              path: /
              port: http
          resources:
{{ toYaml .Values.resources | indent 12 }}
    {{- with .Values.nodeSelector }}
      nodeSelector:
{{ toYaml . | indent 8 }}
    {{- end }}
    {{- with .Values.affinity }}
      affinity:
{{ toYaml . | indent 8 }}
    {{- end }}
    {{- with .Values.tolerations }}
      tolerations:
{{ toYaml . | indent 8 }}
    {{- end }}

Fügen Sie im Ordner „templates“ eine Datei namens secrets.yaml hinzu, um vertrauliche Daten als Kubernetes-Geheimnisse zu speichern.

Tipp

Weitere Informationen zur Verwendung von Kubernetes-Geheimnissen finden Sie hier.

apiVersion: v1
kind: Secret
metadata:
  name: mysecret
type: Opaque
data:
  password: {{ .Values.secrets.password | b64enc }}

Aktualisieren Sie abschließend die Datei values.yaml mit folgendem Inhalt, um optional Standardwerte der Konfigurationseinstellungen und Geheimnisse anzugeben, auf die in den Dateien deployment.yaml und secrets.yaml verwiesen wird. Die tatsächlichen Werte werden durch die aus App Configuration gepullte Konfiguration überschrieben.

# settings will be overwritten by App Configuration
settings:
  color: red
  message: myMessage

Übergeben der Konfiguration aus App Configuration in der Helm-Installation

Laden Sie zunächst die Konfiguration aus App Configuration in eine Datei namens myConfig.yaml herunter. Verwenden Sie einen Schlüsselfilter, um nur die Schlüssel herunterzuladen, die mit settings. beginnen. Sollte der Schlüsselfilter in Ihrem Fall nicht ausreichen, um Schlüssel von Key Vault-Verweisen auszuschließen, können Sie das Argument --skip-keyvault verwenden, um sie auszuschließen.

Tipp

Weitere Informationen zum Exportbefehl finden Sie hier.

az appconfig kv export -n myAppConfiguration -d file --path myConfig.yaml --key "settings.*"  --separator "." --format yaml

Laden Sie als Nächstes Geheimnisse in eine Datei namens mySecrets.yaml herunter. Das Befehlszeilenargument --resolve-keyvault dient zum Auflösen der Key Vault-Verweise, indem die tatsächlichen Werte in Key Vault abgerufen werden. Dieser Befehl muss mit Anmeldeinformationen ausgeführt werden, die über Zugriffsberechtigungen für die entsprechende Key Vault-Instanz verfügen.

Warnung

Die Datei enthält vertrauliche Informationen. Bewahren Sie sie daher an einem sicheren Ort auf, und führen Sie eine Bereinigung durch, wenn Sie sie nicht mehr benötigen.

az appconfig kv export -n myAppConfiguration -d file --path mySecrets.yaml --key "secrets.*" --separator "." --resolve-keyvault --format yaml

Verwenden Sie das Argument -f von „helm upgrade“, um die beiden von Ihnen erstellten Konfigurationsdateien zu übergeben. Dadurch werden die in values.yaml definierten Konfigurationswerte mit den aus App Configuration exportierten Werten überschrieben.

helm upgrade --install -f myConfig.yaml -f mySecrets.yaml "example" ./mychart

Sie können auch das Argument --set für „helm upgrade“ verwenden, um Literalschlüsselwerte zu übergeben. Durch die Verwendung des Arguments --set lässt sich die Speicherung vertraulicher Daten auf dem Datenträger vermeiden.

$secrets = az appconfig kv list -n myAppConfiguration --key "secrets.*" --resolve-keyvault --query "[*].{name:key, value:value}" | ConvertFrom-Json

foreach ($secret in $secrets) {
  $keyvalues += $secret.name + "=" + $secret.value + ","
}

if ($keyvalues){
  $keyvalues = $keyvalues.TrimEnd(',')
  helm upgrade --install --set $keyvalues "example" ./mychart
}
else{
  helm upgrade --install "example" ./mychart
}

Vergewissern Sie sich, dass die Konfigurationen und Geheimnisse erfolgreich festgelegt wurden, indem Sie auf das Kubernetes-Dashboard zugreifen. Wie Sie sehen, wurden die Umgebungsvariablen des Containers mit den Werten color und message aus App Configuration aufgefüllt.

Ein als Key Vault-Verweis in App Configuration gespeichertes Geheimnis (password) wurde auch zu Kubernetes-Geheimnissen hinzugefügt.

Bereinigen von Ressourcen

Wenn Sie die in diesem Artikel erstellten Ressourcen nicht mehr verwenden möchten, löschen Sie die erstellte Ressourcengruppe, um Kosten zu vermeiden.

Wichtig

Das Löschen einer Ressourcengruppe kann nicht rückgängig gemacht werden. Die Ressourcengruppe und alle darin enthaltenen Ressourcen werden unwiderruflich gelöscht. Achten Sie daher darauf, dass Sie nicht versehentlich die falsche Ressourcengruppe oder die falschen Ressourcen löschen. Falls Sie die Ressourcen für diesen Artikel in einer Ressourcengruppe erstellt haben, die andere beizubehaltende Ressourcen enthält, löschen Sie die Ressourcen einzeln über den entsprechenden Bereich, statt die Ressourcengruppe zu löschen.

1. Melden Sie sich beim Azure-Portal an, und klicken Sie auf Ressourcengruppen.
2. Geben Sie im Feld Nach Name filtern den Namen Ihrer Ressourcengruppe ein.
3. Wählen Sie in der Ergebnisliste den Ressourcengruppennamen aus, um eine Übersicht anzuzeigen.
4. Wählen Sie die Option Ressourcengruppe löschen.
5. Sie werden aufgefordert, das Löschen der Ressourcengruppe zu bestätigen. Geben Sie zur Bestätigung den Namen Ihrer Ressourcengruppe ein, und klicken Sie auf Löschen.

Daraufhin werden die Ressourcengruppe und alle darin enthaltenen Ressourcen gelöscht.

Nächste Schritte

In diesem Tutorial haben Sie Azure App Configuration-Daten für die Verwendung in einer Kubernetes-Bereitstellung mit Helm exportiert. Fahren Sie mit den Azure CLI-Beispielen fort, um mehr über die Verwendung von App Configuration zu erfahren.

Azure-Befehlszeilenschnittstelle