Créer un ID de service et une clé d'API

Commencez par créer les données d'identification de compte dont vous avez besoin pour exécuter des opérations sur Secrets Manager et Kubernetes Service.

1. A partir de la ligne de commande, connectez-vous à IBM Cloud via l'interface de ligne de commande IBM Cloud.

   ibmcloud login
   

   Si la connexion échoue, exécutez la commande ibmcloud login --sso pour réessayer. Le paramètre --sso est requis lorsque vous vous connectez avec un ID fédéré. Si cette option est utilisée, allez sur le lien répertorié dans la sortie d'interface de ligne de commande pour générer un code d'accès unique.

2. Créez un ID de service et définissez-le en tant que variable d'environnement.

   export SERVICE_ID=`ibmcloud iam service-id-create kubernetes-secrets-tutorial --description "A service ID for testing ESO integration" --output json | jq -r ".id"`; echo $SERVICE_ID
   

3. Affectez les droits d'ID de service pour lire les secrets à partir de Secrets Manager.

   ibmcloud iam service-policy-create $SERVICE_ID --roles "SecretsReader" --service-name secrets-manager
   

   En affectant l'accès au service Lecteur de secrets, le contrôleur External Secrets dispose d'un niveau d'accès correct pour lire les secrets de Secrets Manager et les transférer dans un cluster Kubernetes.

4. Créez une clé d'API IBM Cloud pour votre ID de service.

   export IBM_CLOUD_API_KEY=`ibmcloud iam service-api-key-create kubernetes-secrets-tutorial $SERVICE_ID --description "An API key for testing ESO integration." --output json | jq -r ".apikey"`
   

   Utilisez cette clé d'API ultérieurement pour configurer Secrets Manager pour votre déploiement de cluster.

Créer un cluster Kubernetes et une instance Secrets Manager

Créez un cluster Kubernetes et une instance d’ Secrets Manager dans votre compte IBM Cloud.

Vous pouvez créer un cluster Kubernetes et une instance de service Secrets Manager par compte IBM Cloud. Si vous disposez déjà des deux ressources dans votre compte, vous pouvez utiliser votre cluster libre et l'instance Secrets Manager pour exécuter le tutoriel.

1. A partir de la ligne de commande, sélectionnez le compte, la région et le groupe de ressources dans lesquels vous souhaitez créer une instance de service Secrets Manager.

   Dans ce tutoriel, vous allez interagir avec la région de Dallas. Si vous êtes connecté à une autre région, veillez à définir Dallas comme région cible en exécutant la commande suivante.

   ibmcloud target -r us-south -g default
   

2. Créez un cluster Kubernetes.

   ibmcloud ks cluster create classic --zone dal10 --flavor free --name my-test-cluster
   

3. Créez une instance Secrets Manager.

   ibmcloud resource service-instance-create my-secrets-manager secrets-manager trial us-south
   

   La mise à disposition de Secrets Manager et de votre cluster Kubernetes dure de 5 à 15 minutes pour se réaliser.

4. Avant de passer à l’étape suivante, vérifiez que votre cluster et votre instance d’ Secrets Manager ont bien été provisionnés.

   1. Vérifiez que le déploiement de votre noeud worker est terminée.

       ibmcloud ks worker ls --cluster my-test-cluster
       ```
       Lorsque la mise à disposition de votre noeud worker est terminée, l'état passe à **Prêt**.
   
       ```sh {: screen}
       ID                                                       Public IP       Private IP      Flavor   State          Status                Zone    Version
       kube-c39pf4ld0m87o3fv1utg-mytestclust-default-000000dd   169.xx.xx.xxx   10.xxx.xx.xxx   free     normal   Ready   mex01   1.20.7_1543
       ```
   2. Ensuite, vérifiez que votre instance Secrets Manager a été mise à disposition avec succès.
   
   ```sh {: pre}
       ibmcloud resource service-instance my-secrets-manager
       ```
       Lorsque la mise à disposition de l'instance est terminée, l'état passe à **Actif**.
   
       ```plaintext {: screen}
       Name:                  my-secrets-manager
       ID:                    crn:v1:bluemix:public:secrets-manager:us-south:a/f047b55a3362ac06afad8a3f2f5586ea:fe06948b-0c6b-4183-8d4b-e6c1d38ff65f::
       GUID:                  fe06948b-0c6b-4183-8d4b-e6c1d38ff65f
       Location:              us-south
       Service Name:          secrets-manager
       Service Plan Name:     trial
       Resource Group Name:   default
       State:                 active
       Type:                  service_instance
       Sub Type:
       Created at:            2021-01-06T17:11:32Z
       Created by:            zara@example.com
       Updated at:            2021-03-31T02:33:26Z
       ```
   

5. Définissez le contexte pour votre cluster Kubernetes dans l'interface de ligne de commande.

   ibmcloud ks cluster config --cluster my-test-cluster
   

6. Vérifiez que les commandes kubectl s'exécutent correctement et que le contexte Kubernetes est défini sur votre cluster.

   kubectl config current-context
   

   Exemple de sortie :

   my-test-cluster/<your_cluster_ID>
   

Créer un profil de confiance à partir de l'interface de programmation

Un profil sécurisé permet à l'opérateur de secrets externes de lire à partir de Secrets Manager, sans avoir à créer un ID de service ni à gérer une clé d'API.

1. Obtenez les noms CRN pour votre instance Secrets Manager et votre cluster Kubernetes.

   CLUSTER_CRN=$(ibmcloud ks cluster get --cluster my-test-cluster --output json | jq -r '.crn')
   SECRETS_MANAGER_CRN=$(ibmcloud resource service-instance my-secrets-manager --output JSON | jq -r '.[0].crn')
   

2. Créez le profil.

   ibmcloud iam trusted-profile-create 'External Secrets'
   

3. Autorisez le cluster Kubernetes à utiliser le profil sécurisé.

   Kubernetes

   ibmcloud iam trusted-profile-rule-create 'External Secrets' --name kubernetes --type Profile-CR --conditions claim:namespace,operator:EQUALS,value:external-secrets --conditions claim:name,operator:EQUALS,value:external-secrets --conditions claim:crn,operator:EQUALS,value:$CLUSTER_CRN --cr-type IKS_SA
   

   OpenShift

   ibmcloud iam trusted-profile-rule-create 'External Secrets' --name kubernetes --type Profile-CR --conditions claim:namespace,operator:EQUALS,value:external-secrets-operator --conditions claim:name,operator:EQUALS,value:cluster-external-secrets --conditions claim:crn,operator:EQUALS,value:$CLUSTER_CRN --cr-type IKS_SA
   

4. Créez une règle d'accès qui permet au profil sécurisé de lire des secrets à partir de votre instance Secrets Manager.

   ibmcloud iam trusted-profile-policy-create 'External Secrets' --roles SecretsReader --service-instance $SECRETS_MANAGER_CRN --service-name secrets-manager
   

Créer un profil de confiance avec Terraform

Un profil sécurisé permet à l'opérateur de secrets externes de lire à partir de Secrets Manager, sans avoir à créer un ID de service ni à gérer une clé d'API. Vous pouvez suivre cet exemple dans Terraform qui exécute toutes les étapes de création d'un profil de confiance :

```sh {: pre}
//Get your cluster details
data "ibm_container_vpc_cluster" "cluster" {
  name              = var.cluster_name
  resource_group_id = var.resource_group_id
}

//Get details of Secret Manager Instance
data "ibm_resource_instance" "secrets_manager" {
  name              = var.sm_name
  resource_group_id = var.resource_group_id
  service           = "secrets-manager"
}

//Create Trusted Profile
resource "ibm_iam_trusted_profile" "eso_profile" {
  name        = var.profile_name
  description = var.profile_description
}

//Attach IAM Policy for Secrets Manager Access
resource "ibm_iam_trusted_profile_policy" "secrets_policy" {
  iam_id = ibm_iam_trusted_profile.eso_profile.id

  roles = ["SecretsReader"]

  resources {
    service = "secrets-manager"
    resource_instance_id = data.ibm_resource_instance.secrets_manager.guid
  }
}

//Add Claim Rule for Kubernetes Service Account
resource "ibm_iam_trusted_profile_claim_rule" "eso_claim_rule" {
  profile_id = ibm_iam_trusted_profile.eso_profile.id
  type       = "Profile-CR"
  cr_type    = "IKS_SA"

  conditions {
    claim    = "name"
    operator = "EQUALS"
    value    = var.service_account_name
  }

  conditions {
    claim    = "namespace"
    operator = "EQUALS"
    value    = var.namespace
  }

  conditions {
    claim    = "crn"
    operator = "EQUALS"
    value    = data.ibm_container_vpc_cluster.cluster.crn
  }
}

//Variables
variable "resource_group_id" {
  description = "Resource Group ID"
  type        = string
}

variable "sm_name" {
  description = "Secret Manager Instance ID"
  type        = string
}

variable "cluster_name" {
  description = "IKS Cluster name"
  type        = string
}

variable "profile_name" {
  type        = string
  description = "Name of the trusted profile"
}

variable "profile_description" {
  type        = string
  description = "Description of the trusted profile"
}

variable "service_account_name" {
  description = "Kubernetes service account name for claim rule"
  type        = string
}

variable "namespace" {
  description = "Kubernetes namespace for claim rule"
  type        = string
}
```

Préparer votre instance Secrets Manager

Enfin, configurez votre instance Secrets Manager pour qu'elle commence à travailler avec des secrets.

1. A partir de la ligne de commande, vérifiez que vous pouvez accéder au plug-in de l'interface de ligne de commande Secrets Manager.

   ibmcloud secrets-manager --help
   

   Vous n'avez pas encore le plug-in? Pour installer le plug-in de de l'interface de ligne de commande Secrets Manager, exécutez ibmcloud plugin install secrets-manager.

2. Exportez une variable d'environnement avec votre URL de point d'extrémité d'API Secrets Manager unique.

   export SECRETS_MANAGER_URL=`ibmcloud resource service-instance my-secrets-manager --output json | jq -r '.[].dashboard_url | .[0:-3]'`; echo $SECRETS_MANAGER_URL
   

3. Créez un groupe de secrets pour votre instance.

Les groupes de secrets sont un moyen d'organiser et de contrôler qui de votre équipe a accès à des secrets spécifiques dans votre instance. Pour créer un groupe de secrets à partir de l'interface de ligne de commande IBM Cloud, utilisez la commande ibmcloud secrets-manager secret-group-create. Exécutez la commande suivante pour créer un groupe de secrets et stocker son ID en tant que variable d'environnement.

```sh {: pre}
export SECRET_GROUP_ID=`ibmcloud secrets-manager secret-group-create --name my-test-secret-group --description "Read and write to my test app" --output json --service-url $SECRETS_MANAGER_URL | jq -r '.id'`; echo $SECRET_GROUP_ID
```
Utilisation d'une invite de commande Windows™ (`cmd.exe`) ou PowerShell ? Si vous rencontrez des erreurs lors de la transmission de contenu JSON sur la ligne de commande, vous devrez peut-être adapter les chaînes en fonction des exigences d'échappement propres à votre système d'exploitation. Pour plus d'informations, voir [Utilisation de guillemets avec des chaînes dans l'interface de ligne de commande IBM Cloud](/docs/cli?topic=cli-quote-strings).
{: tip}

Réussite ! Vous pouvez maintenant stocker le secret dans Secrets Manager que vous souhaitez remplir dans votre cluster Kubernetes. Passez à l'étape suivante.

Configuration de l'Opérateur Secrets externes pour votre cluster

Mettre à jour votre configuration d'application

Une fois que vous avez installé l'Opérateur Secrets externes dans votre cluster, vous pouvez définir Secrets Manager comme le backend des secrets de votre application. Commencez par créer un fichier de configuration qui cible le secret dans Secrets Manager que vous souhaitez utiliser.

1. Dans le répertoire racine de votre application, créez un fichier external-secrets-example.yml.

   touch external-secrets-example.yml
   

2. Modifiez le fichier afin d'inclure des informations sur le secret que vous souhaitez extraire de votre instance Secrets Manager.

   apiVersion: external-secrets.io/v1beta1
   kind: SecretStore
   metadata:
     name: ibmcloud-secrets-manager-example
   spec:
     provider:
       ibm:
         serviceUrl: <endpoint_url>
         auth:
           secretRef:
             secretApiKeySecretRef:
               name: secret-api-key
               key: apikey
   ---
   apiVersion: external-secrets.io/v1beta1
   kind: ExternalSecret
   metadata:
     name: ibmcloud-secrets-manager-example
   spec:
     secretStoreRef:
       name: ibmcloud-secrets-manager-example
       kind: SecretStore
     target:
       name: ibmcloud-secrets-manager-example
     data:
     - secretKey: username
       remoteRef:
         property: username
         key: username_password/<SECRET_ID>
     - secretKey: password
       remoteRef:
         property: password
         key: username_password/<SECRET_ID>
   

   Il existe deux modes que vous choisissez pour travailler par ID secret ou nom de secret. Si vous choisissez un nom de secret, le format passe de secret_type/secret_id à secret_group/secret_type/secret_name.

   Remplacez <endpoint_url> par l'URL de noeud final Secrets Manager que vous avez extraite plus tôt. Remplacez <SECRET_ID> par l'ID unique du secret que vous avez créé à l'étape précédente.

   Si vous utilisez un profil sécurisé pour l'authentification, remplacez le bloc auth par le fragment suivant.

         auth:
           containerAuth:
             profile: "External Secrets"
             iamEndpoint: https://iam.cloud.ibm.com
             tokenLocation: /var/run/secrets/tokens/sa-token
   

3. Appliquez la configuration à votre cluster.

   kubectl apply -f external-secrets-example.yml
   

4. Vérifiez que l'Opérateur Secrets externes peut extraire le secret stocké dans votre instance Secrets Manager .

   kubectl get secret ibmcloud-secrets-manager-example -o json | jq '.data | map_values(@base64d)'
   

   Exemple de sortie :

   {
       "password": "cloudy-rainy-coffee-book",
       "username": "user123"
   }
   

   Réussite ! Vous pouvez maintenant extraire les données de secret stockées dans votre instance Secrets Manager. Passez à l'étape suivante.