So greifen Sie auf Ihre AWS Secret Manager-Geheimnisse in einem Elastic Kubernetes Service-Cluster zu

Mit dem Kubernetes Secrets Store CSI-Treiber können Sie Pods mit Secrets aus dem AWS Secret Manager versorgen.
So können Sie die Funktionen, die der Secrets Manager bietet, in Ihrem EKS-Cluster nutzen. Der Secrets Store CSI-Treiber bindet Secrets aus externen Speichern als Volumes in Ihre Pods ein.
Secret Store-Anbieter sind verfügbar für
AWS,
Azurblau,
Google und
HashiCorp Tresor.
Diese Anbieter ermöglichen die Integration von Geheimnisspeichern in Ihren Kubernetes-Cluster.
Das bedeutet, dass Ihre Anwendung keinen eigenen Code implementieren muss, um mit diesen geheimen Speichern zu interagieren. Der Secrets Store CSI-Treiber ermöglicht es Ihnen, Secrets mit den Kubernetes Secrets zu synchronisieren, indem Sie die Secret Sync aktivieren, damit sie als Umgebungsvariablen in Pods definiert werden können.
Ebenfalls unterstützt wird die Schlüsseldrehung, aber zum Zeitpunkt des Schreibens dieses Artikels ist sie noch in der Alpha-Phase. Um den AWS Secret Manager in Kubernetes zu integrieren, verwenden Sie den 'AWS Secrets and Configuration Provider' (ASCP), ein Plugin für den CSI-Treiber des Secrets Store.
Der Anbieter ruft die Geheimnisse aus dem Secret Manager und die Parameter aus dem Parameterspeicher ab und übergibt sie an den Secrets Store CSI-Treiber.

Installationsanleitung

In der folgenden Anleitung erfahren Sie, wie Sie den CSI-Treiber mit dem AWS Secrets Manager einrichten.
Der Secret-Sync ist aktiviert, so dass Sie Secrets aus dem Secrets Manager als Umgebungsvariablen in Ihren Pods definieren können.

1. Geheimnisse speichern CSI-Treiber

Eine ausführliche Installationsanleitung für den Secrets Store CSI-Treiber finden Sie unter . Oder führen Sie die folgenden Befehle aus (der Parameter syncSecret ist auf true gesetzt):

helm repo add secrets-store-csi-driver https://kubernetes-sigs.github.io/secrets-store-csi-driver/charts
helm install csi-secrets-store secrets-store-csi-driver/secrets-store-csi-driver --set syncSecret.enabled=true --namespace kube-system

Optionale Parameter für das Steuerrad

Die folgenden Funktionen sind nicht standardmäßig aktiviert und können durch Setzen von helm-Parametern aktiviert werden. | Feature | Helm Parameter | | --- | --- | | Sync as Kubernetes secret | syncSecret.enabled=true | | Secret Auto rotation | enableSecretRotation=true | Eine Liste aller Werte, die bei der Ausführung von helm install angepasst werden können, finden Sie unter helm configuration

2. AWS Geheimnisse und Konfigurationsanbieter (ASCP)

Um ASCP zu installieren, verwenden Sie den folgenden Befehl:

kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/deployment/aws-provider-installer.yaml

3. IAM-Rolle

Erstellen Sie eine IAM-Rolle mit der folgenden Richtlinie, um den Zugriff auf den Secret Manager zu ermöglichen.
Diese IAM-Rolle wird mit einem Kubernetes ServiceAccount verbunden.

Minimale Politik

Minimale Berechtigungen für den Abruf von Geheimnissen aus dem Secret Manager.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "",
            "Effect": "Allow",
            "Action": [
                "secretsmanager:GetSecretValue",
                "secretsmanager:DescribeSecret"
            ],
            "Resource": "arn:*:secretsmanager:*:*:secret:MySecret-??????"
        }
    ]
}

Richtlinie für mit KMS verschlüsselte Geheimnisse

Wenn Geheimnisse mit KMS verschlüsselt werden, muss der Benutzer, der die Geheimnisse anfordert, in der Lage sein, den KMS-Schlüssel zu erhalten, der zum Verschlüsseln des Geheimnisses verwendet wurde.
Die zum Entschlüsseln der Geheimnisse erforderlichen Berechtigungen sind kms:GenerateDataKey & kms:Decrypt . Um sicherzustellen, dass der KMS-Schlüssel nur für den Secrets Manager zugänglich ist, verwenden Sie den Bedingungsschlüssel kms:ViaService mit dem Wert secretsmanager.AWS_REGION.amazonaws.com.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
              "kms:GenerateDataKey",
              "kms:Decrypt"
            ],
            "Resource": "*",
            "Condition": {
              "StringEquals": {
                "kms:CallerAccount": [
                  "AWS_ACCOUNT_ID"
                ],
                "kms:ViaService": [
                  "secretsmanager.AWS_REGION.amazonaws.com"
                ]
              }
            }
        },
        {
            "Effect": "Allow",
            "Action": [
                "secretsmanager:GetSecretValue",
                "secretsmanager:DescribeSecret"
            ],
            "Resource": "arn:*:secretsmanager:*:*:secret:MySecret-??????"
        }
    ]
}

4. Kubernetes-Dienstkonto

Der ServiceAccount ermöglicht Ihren Pods den Zugriff auf den Secret Manager mit der zuvor erstellten Rolle.

apiVersion: v1
kind: ServiceAccount
metadata:
  name: secret-manager-service-account
  annotations:
    eks.amazonaws.com/role-arn: arn:aws:iam::<ACCOUNT_ID>:role/<IAM_ROLE_NAME>

5. SecretProviderClass erstellen

Sie konfigurieren ein oder mehrere Secrets, die Sie benötigen, über die benutzerdefinierte Kubernetes-Ressource SecretProviderClass.
Der Pod hängt die Secrets als Volume von dieser benutzerdefinierten Ressource ein. Die secretObjects wird verwendet, um die Secrets mit Kubernetes Secrets zu synchronisieren. (funktioniert nur, wenn Secret Sync aktiviert ist)

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: secrets-provider
spec:
  provider: aws
  secretObjects:
    - secretName: database_password
      type: Opaque
      data:
        - objectName: "MySecretPassword"
          key: password
  parameters:
    objects: |
      - objectName: arn:*:secretsmanager:*:*:secret:MySecret-??????
        objectAlias: "MySecretPassword"

JSON-formatiertes Geheimnis

Wenn Ihr Geheimnis aus dem AWS Secrets Manager ein JSON-formatiertes Geheimnis ist, verwenden Sie jmesPath. Damit können Sie ein bestimmtes Schlüssel-Wert-Paar aus der JSON-Datei abrufen. Beispiel JSON-Geheimnis:

{
    "username": "username",
    "password": "password"
}

Um den Benutzernamen und das Passwort aus der JSON-Datei abzurufen, verwenden Sie jmesPath wie folgt:

  parameters:
    objects: |
      - objectName: arn:*:secretsmanager:*:*:secret:MySecret-??????
        jmesPath:
            - path: "username"
              objectAlias: "MySecretUsername"
            - path: "password"
              objectAlias: "MySecretPassword"

6. Konfigurieren Sie das Volume für den Pod

Nachfolgend finden Sie ein Kubernetes-Manifest, das zeigt, wie Sie SecretProviderClass als Volume hinzufügen.
Die Geheimnisse als Datei verfügbar machen, die Sie unter /mnt/secrets-store finden.
Oder die Geheimnisse können als Umgebungsvariablen in einem Pod definiert werden.

kind: Pod
apiVersion: v1
metadata:
  name: secrets-store-inline
spec:
  serviceAccountName: secret-manager-service-account # The ServiceAccount with permissions to access the Secret Manager secret 
  containers:
    volumeMounts:
    - name: secrets-store-inline
      mountPath: "/mnt/secrets-store"
      readOnly: true
    env:
    - name: DATABASE_PASSWORD
      valueFrom:
        secretKeyRef:
          name: database_password # Name of the secret in Kubernetes Secrets, which has been set in the secretProviderClass 
          key: password
  volumes:
  - name: secrets-store-inline
    csi:
      driver: secrets-store.csi.k8s.io
      readOnly: true
      volumeAttributes:
        secretProviderClass: "secrets-provider" # Name of the secretProviderClass

Quellen

• GitHub: secrets-store-csi-driver
• Secrets Store CSI Driver Steuerkonfiguration: Steuerkonfiguration
• GitHub: secrets-store-csi-driver-provider-aws
• AWS Doc: Verwendung von Secrets Manager-Geheimnissen in Amazon Elastic Kubernetes Service
• Doc: Kubernetes Geheimnisse speichern CSI-Treiber