Key Management Service:Déployer KMS Agent dans ACK pour récupérer des secrets

Étape 1 : Générer l'exécutable KMS Agent

1. Installez Go. Pour obtenir des instructions, consultez le guide d'installation de Go.

2. Téléchargez le code source et les dépendances.

   1. Téléchargez et installez Git depuis le site officiel de Git.

   2. Exécutez les commandes suivantes pour cloner le dépôt et télécharger les dépendances :

      git clone https://github.com/aliyun/alibabacloud-kms-agent
      go mod download

3. Dans le répertoire racine du projet, exécutez go build . pour compiler l'exécutable. Le nom par défaut de l'exécutable est alibabacloud-kms-agent et il est enregistré dans le répertoire racine du projet.

   Si l'environnement de build et l'environnement de déploiement sont identiques, exécutez directement go build .. Pour les builds multiplateformes, utilisez les commandes suivantes pour générer un exécutable 64 bits :

   Environnement de build	Déploiement sur macOS	Déploiement sur Linux	Déploiement sur Windows
   macOS	go build .	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build .	CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build .
   Linux	CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 go build .	go build .	CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build .
   Windows	SET CGO_ENABLED=0 && SET GOOS=darwin && SET GOARCH=amd64 && go build .	SET CGO_ENABLED=0 && SET GOOS=linux && SET GOARCH=amd64 && go build .	go build .

4. Dans le répertoire racine du projet, vérifiez que l'exécutable alibabacloud-kms-agent existe.

Étape 2 : Activer RRSA et autoriser l'accès aux secrets

1. Activez RRSA pour votre cluster ACK.

   Activer lors de la création du cluster

   Lorsque vous créez un ACK managed cluster et un ACK Edge cluster, vous pouvez activer RRSA dans la section Advanced Options (Optional) de la configuration du cluster.

   Activer sur la page d'informations du cluster

   1. Connectez-vous à la console ACK. Dans le volet de navigation de gauche, cliquez sur Clusters.

   2. Sur la page Clusters, cliquez sur le nom de votre cluster. Dans le volet de navigation de gauche, cliquez sur Cluster Information.

   3. Dans l'onglet Basic Information, dans la section Security and Auditing, cliquez sur Enable à côté de RRSA OIDC.

   4. Dans la boîte de dialogue Enable RRSA, cliquez sur OK.

      Remarque

      Sur la page Basic Information, lorsque l'état du cluster passe de Updating à Running, la fonctionnalité RRSA est activée pour le cluster.

2. Accédez à la page des détails du cluster. Dans l'onglet Basic Information, dans la section Security and Auditing, survolez l'état activé à côté de RRSA OIDC pour afficher l'URL du fournisseur et l'ARN. Une fois RRSA activé, cette section affiche l'Provider URL et l'Provider ARN de RRSA OIDC. Vous aurez besoin de ces deux valeurs lors de la configuration de la politique d'approbation du rôle RAM.

3. Créez un rôle RAM avec un fournisseur d'identité comme entité de confiance.

   1. Connectez-vous à la console RAM en tant qu'administrateur RAM. Dans le volet de navigation de gauche, choisissez Identities > Roles.

   2. Cliquez sur Create Role. Sur la page de création, cliquez sur Switch to Policy Editor dans le coin supérieur droit.

   3. Dans l'éditeur, spécifiez le fournisseur d'identité OIDC. Sélectionnez le mode Visual Editor et configurez les paramètres suivants :

      Remarque

      Pour plus d'informations sur les autres modes, consultez Créer un rôle RAM pour un fournisseur d'identité OIDC.

      1. Dans la section Principal, sélectionnez IdP, puis cliquez sur Edit.

      2. Dans la boîte de dialogue Add Principal, configurez les paramètres suivants :

         • IdP Type : Sélectionnez OIDC.

         • IdP : Une fois RRSA activé, ACK crée un fournisseur d'identité par défaut nommé ack-rrsa-<cluster_id>, où <cluster_id> correspond à l'ID de votre cluster.

         • Action : Conservez la valeur par défaut sts:AssumeRole.

         • Condition : Ajoutez une nouvelle condition aux côtés des conditions par défaut oidc:iss et oidc:aud :

           • Condition key : Sélectionnez oidc:sub.

           • Operator : Sélectionnez StringEquals.

           • Condition value : Saisissez system:serviceaccount:<namespace>:<serviceAccountName>.

             • <namespace> : Le namespace où réside l'application.

             • <serviceAccountName> : Le nom du compte de service.

             Cet exemple utilise system:serviceaccount:rrsa-dev:dev-sa, où rrsa-dev est le namespace Kubernetes et dev-sa est le compte de service que vous créerez à l'étape 3.

   4. Dans la boîte de dialogue Create Role, définissez un nom de rôle et cliquez sur OK. Cet exemple utilise dev-role-for-rrsa.

   5. Vérifiez la politique d'approbation pour dev-role-for-rrsa. La politique permet à un compte de service spécifique d'endosser le rôle RAM via RRSA après avoir réussi l'authentification OIDC.

      {
        "Statement": [
          {
            "Action": "sts:AssumeRole",
            "Condition": {
              "StringEquals": {
                "oidc:aud": [
                  "sts.aliyuncs.com"
                ],
                "oidc:iss": [
                  "https://oidc-ack-cn-hongkong.oss-cn-hongkong.aliyuncs.com/cf01******"
                ],
                "oidc:sub": [
                  "system:serviceaccount:rrsa-dev:dev-sa"
                ]
              }
            },
            "Effect": "Allow",
            "Principal": {
              "Federated": [
                "acs:ram::5269************:oidc-provider/ack-rrsa-cf01******"
              ]
            }
          }
        ],
        "Version": "1"
      }

4. Créez une politique d'autorisation et attachez-la au rôle RAM.

   1. Créez une politique d'autorisation. Cet exemple utilise le nom de politique dev-role-for-rrsa-kms-policy et n'autorise l'accès qu'aux secrets tagués avec env:dev.

      

      Le contenu de la politique est le suivant :

      {
          "Version": "1",
          "Statement": [
              {
                  "Effect": "Allow",
                  "Action": [
                      "kms:Decrypt",
                      "kms:GetSecretValue"
                  ],
                  "Resource": "*",
                  "Condition": {
                      "StringEqualsIgnoreCase": {
                          "kms:tag/env": [
                              "dev"
                          ]
                      }
                  }
              }
          ]
      }

   2. Attachez la politique dev-role-for-rrsa-kms-policy au rôle dev-role-for-rrsa.

      

Étape 3 : Créer un namespace et un compte de service

Un namespace divise un cluster ACK en espaces virtuels logiquement isolés pour différents environnements tels que le développement, les tests et la production. Par défaut, les applications situées dans différents namespaces ne peuvent pas accéder aux ressources des autres. Un compte de service fournit une identité à un Pod et se lie dynamiquement à un rôle RAM via RRSA.

1. Créez un fichier YAML de namespace.

   Créez un fichier nommé namespace.yaml avec le contenu suivant. Cet exemple crée un namespace nommé rrsa-dev.

   apiVersion: v1
   kind: Namespace
   metadata:
     name: rrsa-dev

2. Exécutez la commande suivante pour créer le namespace :

   kubectl apply -f namespace.yaml

   Vérifiez que le namespace a été créé :

   kubectl get namespaces

   Si la sortie inclut rrsa-dev, le namespace a été créé avec succès.

3. Créez un fichier YAML de compte de service.

   Créez un fichier nommé serviceaccount.yaml avec le contenu suivant. Cet exemple crée un compte de service nommé dev-sa dans le namespace rrsa-dev.

   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: dev-sa
     namespace: rrsa-dev

4. Exécutez la commande suivante pour créer le compte de service :

   kubectl apply -f serviceaccount.yaml

   Vérifiez que le compte de service a été créé :

   kubectl get serviceaccount -n rrsa-dev

   Si la sortie inclut dev-sa, le compte de service a été créé avec succès.

Étape 4 : Générer l'image du conteneur sidecar

Empaquetez KMS Agent en tant que conteneur sidecar pour le déployer aux côtés de votre application dans ACK.

1. Configurez les paramètres d'exécution de KMS Agent dans config.toml.

   Remarque

   Le fichier config.toml se trouve dans le répertoire configs du code source alibabacloud-kms-agent obtenu à l'étape 1.

   [Server]
   HttpPort = 2025
   
   [KMS]
   Region = "cn-hangzhou"
   
   [Cache]
   CacheType = "InMemory"
   CacheSize = 1000
   TtlSeconds = 300
   
   [Log]
   LogLevel = "Debug"
   LogPath = "./logs/"
   MaxSize = 100
   MaxBackups = 2

2. Créez un Dockerfile.

   Par exemple, créez un Dockerfile dans deploy/ack/agent pour déployer l'agent. Pour le contenu du fichier, consultez agent_Dockerfile.

   # Use the centos image as the base
   FROM centos:centos7
   
   # Set the working directory inside the container
   WORKDIR /usr/local/alibabacloudkmsagent
   
   # Copy the binary and config to the container
   COPY alibabacloud-kms-agent .
   COPY config.toml .
   
   # Set the entry point to run the kms agent
   ENTRYPOINT ["./alibabacloud-kms-agent", "agent", "./config.toml"]

3. Copiez l'exécutable et la configuration dans le répertoire deploy/ack/agent :

   deploy/ack/agent
   ├── alibabacloud-kms-agent
   ├── config.toml
   ├── Dockerfile.agent

4. Générez l'image sidecar et poussez-la vers Container Registry :

   # Build the image.
   docker build -t registry.cn-hangzhou.aliyuncs.com/<ns>/<repo>:kmsagent-v1.0 .
   # Push the image.
   docker push registry.cn-hangzhou.aliyuncs.com/<ns>/<repo>:kmsagent-v1.0

Étape 5 : Générer l'image du conteneur d'application

1. Pour une application déployée dans deploy/ack/app, créez un Dockerfile dans ce répertoire :

   # Use the centos image as the base
   FROM centos:centos7
   
   # Set the working directory inside the container
   WORKDIR /
   
   # Set the entry point to run the kms agent
   ENTRYPOINT ["sleep", "360000"]

2. Générez l'image de l'application et poussez-la vers Container Registry :

   # Build the image.
   docker build -t registry.cn-hangzhou.aliyuncs.com/<ns>/<repo>:app-v1.0 .
   # Push the image.
   docker push registry.cn-hangzhou.aliyuncs.com/<ns>/<repo>:app-v1.0

Étape 6 : Déployer l'application

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
  namespace: rrsa-dev
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      serviceAccountName: dev-sa
      containers:
      - name: kmsagent
        image: registry-vpc.cn-hangzhou.aliyuncs.com/<ns>/<repo>:kmsagent-v1.0
        env:
        - name: ALIBABA_CLOUD_ROLE_ARN
          value: acs:ram::<uid>:role/dev-role-for-rrsa
        - name: ALIBABA_CLOUD_OIDC_PROVIDER_ARN
          value: acs:ram::<uid>:oidc-provider/ack-rrsa-<ackClusterId>
        - name: ALIBABA_CLOUD_OIDC_TOKEN_FILE
          value: /var/run/secrets/ack.alibabacloud.com/rrsa-tokens/token
        - name: KMS_TOKEN
          value: file:///var/run/kmstoken/token
        volumeMounts:
          - name: shared-volume
            mountPath: /var/run/kmstoken
          - name: rrsa-oidc-token
            mountPath: /var/run/secrets/ack.alibabacloud.com/rrsa-tokens
            readOnly: true
        command: ["/bin/sh", "-c", "./alibabacloud-kms-agent token /var/run/kmstoken/token && ./alibabacloud-kms-agent agent config.toml"]
      - name: my-app
        image: registry-vpc.cn-hangzhou.aliyuncs.com/<ns>/<repo>:app-v1.0
        volumeMounts:
          - name: shared-volume
            mountPath: /var/run/kmstoken
      volumes:
        - name: shared-volume
          emptyDir: {}
        - name: rrsa-oidc-token
          projected:
            defaultMode: 420
            sources:
            - serviceAccountToken:
               audience: sts.aliyuncs.com
               expirationSeconds: 3600
               path: token

Étape 7 : Créer et récupérer un secret

1. Créez un secret dans KMS.

   Ajoutez le tag env:dev lors de la création du secret. Le conteneur d'application ne peut accéder qu'aux secrets portant ce tag.

   1. Connectez-vous à la console Key Management Service. Dans la barre de navigation supérieure, sélectionnez une région. Dans le volet de navigation de gauche, choisissez Resources > Secrets.

   2. Cliquez sur l'onglet Generic Secrets, sélectionnez un Instance ID, puis cliquez sur Create Secret. Configurez les paramètres et cliquez sur OK.

      Paramètre	Description
      Secret Name	Un nom d'identifiant personnalisé. Doit être unique dans la région actuelle.
      Secret Value	Sélectionnez Clé/Valeur du secret ou Texte brut et saisissez les données sensibles à stocker. La valeur doit avoir une longueur maximale de 30 720 octets (30 Ko).
      Initial Version	Le numéro de version initial. Valeur par défaut : v1. Les valeurs personnalisées sont prises en charge.
      CMK	Sélectionnez la clé symétrique utilisée pour chiffrer la valeur de l'identifiant. La clé et l'identifiant doivent appartenir à la même instance KMS. Important La clé et l'identifiant doivent appartenir à la même instance KMS, et la clé doit être une clé symétrique. Pour plus d'informations sur les clés symétriques prises en charge par KMS, consultez Types et spécifications de clés. Si un utilisateur RAM ou un rôle RAM est utilisé, il doit disposer des autorisations nécessaires pour effectuer l'opération GenerateDataKey à l'aide de la clé maître de chiffrement.
      Tags	Ajoutez des tags à l'identifiant pour la classification. Chaque tag se compose d'une paire clé-valeur. Remarque Format d'une clé de tag et d'une valeur de tag : Une clé de tag ou une valeur de tag peut comporter jusqu'à 128 caractères et contenir des lettres, des chiffres, des barres obliques (/), des barres obliques inverses (\), des traits de soulignement (_), des traits d'union (-), des points (.), des signes plus (+), des signes égal (=), des deux-points (:), des arobases (@) et des espaces. Une clé de tag ne peut pas commencer par aliyun ou acs:. Chaque identifiant prend en charge jusqu'à 20 paires clé-valeur de tag.
      Description	Une description facultative de l'identifiant pour l'identification et la gestion.
      Advanced Settings > Policy Settings	Définissez la stratégie d'accès pour l'identifiant afin de contrôler quels utilisateurs ou rôles RAM peuvent le lire ou le modifier. Vous pouvez d'abord sélectionner la stratégie par défaut et la modifier ultérieurement selon vos besoins.

2. Récupérez la valeur du secret.

   • Utilisez la commande curl :

     curl -v -H "X-KMS-Token:$(</var/run/kmstoken/token)" 'http://localhost:2025/secretsmanager/get?secretId=app/dev/secret-1'

   • Récupérez le secret dans le code de votre application via une requête HTTP GET :

     package main
     
     import (
     	"fmt"
     	"io/ioutil"
     	"net/http"
     )
     
     func main() {
     	url := fmt.Sprintf("http://localhost:2025/secretsmanager/get?secretId=%s", "app/dev/secret-1")
     
     	token, err := ioutil.ReadFile("/var/run/kmstoken/token")
     	if err != nil {
     		fmt.Printf("error reading token file: %v\n", err)
     	}
     
     	req, err := http.NewRequest("GET", url, nil)
     	if err != nil {
     		fmt.Printf("error creating request: %v\n", err)
     	}
     
     	req.Header.Add("X-KMS-Token", string(token))
     
     	client := &http.Client{}
     	resp, err := client.Do(req)
     	if err != nil {
     		fmt.Printf("error sending request: %v \n", err)
     	}
     	defer resp.Body.Close()
     
     	body, _ := ioutil.ReadAll(resp.Body)
     	fmt.Printf("status code %d - %s \n", resp.StatusCode, string(body))
     }