Protection de vos données sensibles dans Continuous Delivery

Le service Continuous Delivery chiffre les données sensibles appartenant au client avant de les stocker dans des bases de données utilisées par le service en interne. Les données sensibles comprennent les données de configuration d'intégration d'outils tiers et des valeurs de propriétés Delivery Pipeline. Les données sont chiffrées à l'aide de clés de chiffrement internes au service Continuous Delivery ou à l'aide de clés de chiffrement dérivées de la clé racine spécifiée dans une instance du service IBM® Key Protect for IBM Cloud® ou du service IBM Cloud® Hyper Protect Crypto Services.

Les processus DevOps requièrent souvent différents types de données d'identification (par exemple, des noms d'utilisateur et des mots de passe, des clés d'API, des clés de service et des clés SSH) pour interagir avec d'autres systèmes afin de générer, tester et déployer des applications. C'est à vous de garantir que ces données d'identification ne sont pas partagées par inadvertance avec des utilisateurs auxquels elles sont destinées. L'accès à ces données d'identification par des intervenants malveillants peut perturber vos opérations informatiques, entraîner des coûts imprévus ou l'utilisation de vos ressources pour lancer des attaques. IBM n'est pas responsable de la protection et du maintien de la sécurité de vos données d'identification.

Pour sécuriser vos données d'identification, veillez à suivre les conseils suivants :

• Ne stockez pas les données d'identification dans des référentiels Git. Selon les paramètres du référentiel, les fichiers d'un référentiel peuvent être visibles par les autres membres de votre organisation, les autres utilisateurs IBM Cloud ou l'Internet public.
• N'incluez pas les données d'identification d'utilisateur dans des définitions Delivery Pipeline car elles pourraient être visibles par d'autres utilisateurs. Plus précisément, ne placez pas les données d'identification de l'utilisateur dans des scripts de définition de travail Delivery Pipeline Classic, des fichiers yaml Delivery Pipeline Tekton ou des scripts démarrés par des pipelines de distribution.
• Ne publiez pas les données d'identification d'utilisateur dans des fichiers journaux créés lors de l'exécution d'un pipeline car ces fichiers pourraient être partagés.
• Ne spécifiez pas de données d'identification en texte en clair dans les appels aux API Continuous Delivery, par exemple lorsque vous configurez des intégrations d'outils, des propriétés d'environnement de pipeline Tektonou des propriétés de déclencheur de pipeline Tekton.
• N'incluez pas de données d'identification, d'informations d'identification personnelle ou d'autres informations sensibles dans les appels à l'API POST /toolchains/{toolchain_id}/events. L'API envoie des événements contenant les données que vous spécifiez aux instances de Event Notifications qui sont intégrées à la chaîne d'outils. Event Notifications transmettra ensuite les événements à des destinations configurées telles que le courrier électronique, les SMS et Slack.
• Ne spécifiez pas de données d'identification en texte en clair dans les fichiers de configuration Terraform, par exemple lorsque vous définissez des ressources d'intégration d'outils, des ressources de propriété d'environnement de pipeline Tekton ou des ressources de propriété de déclencheur de pipeline Tekton. A la place, gérez les données d'identification dans un service de stockage de secrets et spécifiez-les par référence dans les appels d'API et les configurations Terraform. Pour plus d'informations sur la gestion des secrets par référence, voir Protection de vos données d'identification à l'aide de références de secrets.

IBM Cloud fournit plusieurs options que vous pouvez utiliser pour le stockage des clés sécurisées et des valeurs confidentielles.

• Propriétés d'environnement sécurisé de pipeline Classic
• Propriétés d'environnement sécurisé de pipeline Tekton
• IBM® Key Protect for IBM Cloud®
• IBM Cloud® Hyper Protect Crypto Services
• HashiCorp Vault

Pour plus d'informations sur les meilleures pratiques DevOps sécurisées, voir DevOps Security.

Protection de vos données d'identification à l'aide de références de secrets

De nombreuses propriétés que vous pouvez configurer lorsque vous utilisez des chaînes d'outils et des pipelines de distribution Continuous Delivery, tels que des mots de passe, des clés d'API, des certificats ou d'autres jetons, sont classées en tant que secrets ou données d'identification. Pour définir la valeur d'une propriété sécurisée, vous pouvez utiliser un texte en clair ou une référence de secrets. L'utilisation d'une référence de secrets est la méthode recommandée pour définir la valeur d'une propriété sécurisée.

Lorsque vous définissez une propriété sécurisée avec une valeur confidentielle texte en clair, Continuous Delivery chiffre et stocke la valeur en interne. Bien que la valeur soit sécurisée dans le service Continuous Delivery, le service ne peut pas protéger la valeur côté client. Lorsque vous définissez une propriété sécurisée à l'aide de la console de votre navigateur, en appelant une API ou en configurant une ressource Terraform, le secret en texte clair peut être exposé sur vos systèmes locaux. Les secrets en texte clair sont également plus difficiles à faire pivoter. Lorsqu'un secret, tel qu'une clé d'API, doit faire l'objet d'une rotation, toutes les propriétés sécurisées qui portent la valeur de secret doivent également être localisées et mises à jour.

Lorsque vous définissez une propriété sécurisée avec une valeur de référence de secrets, la valeur est une chaîne spécialement formatée qui fait référence à l'emplacement ou à l'adresse d'un secret géré au sein d'un service de stockage de secrets tel que IBM® Key Protect for IBM Cloud®, IBM Cloud® Secrets Manager ou HashiCorp Vault. Bien que Continuous Delivery chiffre et stocke activement la valeur de référence des secrets en interne, la valeur de secret n'est pas exposée côté client. Lorsque Continuous Delivery doit extraire le secret pour effectuer un traitement en votre nom, il extrait en interne la valeur du magasin de secrets référencé. Les références de secrets sont également résilientes à la rotation. Généralement, lorsqu'un secret fait l'objet d'une rotation dans un magasin de secrets, l'emplacement ou l'adresse du secret reste le même. Seule la valeur de secret elle-même est modifiée.

Deux types de références de secrets sont pris en charge: par nom ou par Cloud Resource Name(CRN). Actuellement, seules les intégrations d'outils Secrets Manager prennent en charge le référencement des secrets par CRN. Ce format offre une plus grande flexibilité car vous pouvez référencer des secrets à partir d'une instance Secrets Manager dans un autre compte si l'autorisation correcte est en place.

Veillez à prendre en compte les prérequis suivants pour la spécification d'une référence de secrets dans la portée d'une chaîne d'outils:

• Le magasin de secrets doit être ajouté à la chaîne d'outils en tant qu'intégration d'outils. Pour plus d'informations sur les intégrations d'outils de stockage de secrets, voir Configuring Key Protect, Configuring Secrets Manager, et Configuring HashiCorp Vault.
• Une règle d'autorisation de service à service IAM doit être configurée pour permettre à la chaîne d'outils source d'extraire des secrets du magasin de secrets cible. Pour plus d'informations sur les autorisations de service à service, voir Utilisation des autorisations pour accorder l'accès entre les services.

Lorsque vous travaillez en dehors de la console, par exemple avec l'API ou Terraform, utilisez le format suivant pour les références de secrets par nom:

• {vault::SECRET_STORE_INTEGRATION_NAME.SECRET_NAME} lorsque vous référencez des secrets qui sont contenus dans Key Protect.
• {vault::SECRET_STORE_INTEGRATION_NAME.SECRET_GROUP_NAME.SECRET_NAME} lorsque vous référencez des secrets qui sont contenus dans Secrets Manager.
• {vault::SECRET_STORE_INTEGRATION_NAME.SECRET_NAME.FIELD_NAME} lorsque vous faites référence à des secrets contenus dans HashiCorp Vault.

Valeur secrète :

• ref://secrets-manager.REGION.RESOURCE-GROUP.SECRETS-MANAGER-INSTANCE-NAME1/SECRETS-GROUP-NAME/SECRET-NAME lorsque vous référencez des secrets qui sont contenus dans Key Protect.
• ref://secrets-manager.eu-de.EU-RG.SM-1/default/api-key lorsque vous référencez des secrets qui sont contenus dans Secrets Manager.

Par exemple, si le secret concerne une valeur de clé, vous pouvez sélectionner la clé :

• ref://secrets-manager.eu-gb.Default.Secrets%20Manager-zc/Default/mk-kv-pair?key=ibmcloud-api-key

où :

• SECRETS-MANAGER-INSTANCE-NAME1 est le nom de l'intégration du magasin de secrets dans la chaîne d'outils, et non le nom de l'instance de service du magasin de secrets.
• SECRET_GROUP_NAME est le nom du groupe qui contient le secret dans Secrets Manager.
• SECRET_NAME est le nom du secret dans le magasin de secrets.
• KEY_NAME est le nom de la clé dans le secret clé-valeur.

Pour utiliser une référence de secrets CRN, procurez-vous le CRN secret directement à partir de l'interface utilisateur Secrets Manager ou à l'aide d'un programme à l'aide de l'interface de ligne de commande, de l'API ou de logiciels SDK.

export CD_TOOLCHAIN_AUTH_TYPE=iam && \
export CD_TOOLCHAIN_APIKEY={iam_api_key} && \
export CD_TOOLCHAIN_URL=https://api.us-south.devops.cloud.ibm.com/toolchain/v2

curl -X POST \
https://api.us-south.devops.cloud.ibm.com/toolchain/v2/toolchains/01234567-89ab-cdef-0123-456789abcdef/tools \
-H "Authorization: Bearer $TOKEN" \
-H 'Accept: application/json' \
-H 'Content-Type: application/json' \
-d '{
    "tool_type_id": "slack",
    "parameters": {
    "api_token": "{vault::my-kms-tool-integration.my-slack-webhook}",
    "channel_name": "my_slack_channel_name",
    "team_url": "my_slack_team_name"
    }
}'

const CdToolchainV2 = require('@ibm-cloud/continuous-delivery/cd-toolchain/v2');
...
(async () => {
    const toolchainService = CdToolchainV2.newInstance();
    const slackParameters = {
        api_token: "{vault::my-kms-tool-integration.my-slack-webhook}",
        channel_name: "my_slack_channel_name",
        team_url: "my_slack_team_name"
    };
    const toolPrototypeModel = {
        toolchainId: "01234567-89ab-cdef-0123-456789abcdef",
        toolTypeId: "slack",
        parameters: slackParameters
    };
    const slackTool = await toolchainService.createTool(toolPrototypeModel);
})();

import (
    "github.com/IBM/continuous-delivery-go-sdk/cdtoolchainv2"
)
...
toolchainClientOptions := &cdtoolchainv2.CdToolchainV2Options{}
toolchainClient, err := cdtoolchainv2.NewCdToolchainV2UsingExternalConfig(toolchainClientOptions)
slackParameters := map[string]interface{}{
    "api_token": "{vault::my-kms-tool-integration.my-slack-webhook}",
    "channel_name": "my_slack_channel_name",
    "team_url": "my_slack_team_name",
}
createToolOptions := toolchainClient.NewCreateToolOptions("01234567-89ab-cdef-0123-456789abcdef", "slack")
createToolOptions.SetParameters(slackParameters)
slackTool, response, err := toolchainClient.CreateTool(createToolOptions)

from ibm_continuous_delivery.cd_toolchain_v2 import CdToolchainV2
...
toolchain_service = CdToolchainV2.new_instance()
slack_parameters = {
    "api_token": "{vault::my-kms-tool-integration.my-slack-webhook}",
    "channel_name": "my_slack_channel_name",
    "team_url": "my_slack_team_name"
}
slack_tool = toolchain_service.create_tool(
    toolchain_id = "01234567-89ab-cdef-0123-456789abcdef",
    tool_type_id = "slack",
    parameters = slack_parameters
)

   import com.ibm.cloud.continuous_delivery.cd_toolchain.v2.CdToolchain;
   import com.ibm.cloud.continuous_delivery.cd_toolchain.v2.model.*;
   ...
   CdToolchain toolchainService = CdToolchain.newInstance();
   HashMap<String, Object> slackParameters = new HashMap<>();
   slackParameters.put("api_token", "{vault::my-kms-tool-integration.my-slack-webhook}");
   slackParameters.put("channel_name", "my_slack_channel_name");
   slackParameters.put("team_url", "my_slack_team_name");
   CreateToolOptions createSlackToolOptions = new CreateToolOptions.Builder()
      .parameters(slackParameters)
      .toolchainId({toolchain_id})
      .toolTypeId("slack")
      .build();
   Response<ToolchainToolPost> response = toolchainService.createTool(createSlackToolOptions).execute();
   ToolchainToolPost slackTool = response.getResult();

curl -X POST \
https://api.us-south.devops.cloud.ibm.com/toolchain/v2/toolchains/01234567-89ab-cdef-0123-456789abcdef/tools \
-H "Authorization: Bearer $TOKEN" \
-H 'Accept: application/json' \
-H 'Content-Type: application/json' \
-d '{
    "tool_type_id": "slack",
    "parameters": {
    "api_token": "crn:v1:bluemix:public:secrets-manager:us-south:a/9bb43e401a7a87d15145da761da98571:604de62c-c04f-3f5e-b7e8-4acafe0ecde7:secret:5ec17023-b631-fbcb-ef9c-4f2eb01f1dda",
    "channel_name": "my_slack_channel_name",
    "team_url": "my_slack_team_name"
    }
}'

const CdToolchainV2 = require('@ibm-cloud/continuous-delivery/cd-toolchain/v2');
...
(async () => {
    const toolchainService = CdToolchainV2.newInstance();
    const slackParameters = {
        api_token: "crn:v1:bluemix:public:secrets-manager:us-south:a/9bb43e401a7a87d15145da761da98571:604de62c-c04f-3f5e-b7e8-4acafe0ecde7:secret:5ec17023-b631-fbcb-ef9c-4f2eb01f1dda",
        channel_name: "my_slack_channel_name",
        team_url: "my_slack_team_name"
    };
    const toolPrototypeModel = {
        toolchainId: "01234567-89ab-cdef-0123-456789abcdef",
        toolTypeId: "slack",
        parameters: slackParameters
    };
    const slackTool = await toolchainService.createTool(toolPrototypeModel);
})();

import (
    "github.com/IBM/continuous-delivery-go-sdk/cdtoolchainv2"
)
...
toolchainClientOptions := &cdtoolchainv2.CdToolchainV2Options{}
toolchainClient, err := cdtoolchainv2.NewCdToolchainV2UsingExternalConfig(toolchainClientOptions)
slackParameters := map[string]interface{}{
    "api_token": "crn:v1:bluemix:public:secrets-manager:us-south:a/9bb43e401a7a87d15145da761da98571:604de62c-c04f-3f5e-b7e8-4acafe0ecde7:secret:5ec17023-b631-fbcb-ef9c-4f2eb01f1dda",
    "channel_name": "my_slack_channel_name",
    "team_url": "my_slack_team_name",
}
createToolOptions := toolchainClient.NewCreateToolOptions("01234567-89ab-cdef-0123-456789abcdef", "slack")
createToolOptions.SetParameters(slackParameters)
slackTool, response, err := toolchainClient.CreateTool(createToolOptions)

from ibm_continuous_delivery.cd_toolchain_v2 import CdToolchainV2
...
toolchain_service = CdToolchainV2.new_instance()
slack_parameters = {
    "api_token": "crn:v1:bluemix:public:secrets-manager:us-south:a/9bb43e401a7a87d15145da761da98571:604de62c-c04f-3f5e-b7e8-4acafe0ecde7:secret:5ec17023-b631-fbcb-ef9c-4f2eb01f1dda",
    "channel_name": "my_slack_channel_name",
    "team_url": "my_slack_team_name"
}
slack_tool = toolchain_service.create_tool(
    toolchain_id = "01234567-89ab-cdef-0123-456789abcdef",
    tool_type_id = "slack",
    parameters = slack_parameters
)

   import com.ibm.cloud.continuous_delivery.cd_toolchain.v2.CdToolchain;
   import com.ibm.cloud.continuous_delivery.cd_toolchain.v2.model.*;
   ...
   CdToolchain toolchainService = CdToolchain.newInstance();
   HashMap<String, Object> slackParameters = new HashMap<>();
   slackParameters.put("api_token", "crn:v1:bluemix:public:secrets-manager:us-south:a/9bb43e401a7a87d15145da761da98571:604de62c-c04f-3f5e-b7e8-4acafe0ecde7:secret:5ec17023-b631-fbcb-ef9c-4f2eb01f1dda");
   slackParameters.put("channel_name", "my_slack_channel_name");
   slackParameters.put("team_url", "my_slack_team_name");
   CreateToolOptions createSlackToolOptions = new CreateToolOptions.Builder()
      .parameters(slackParameters)
      .toolchainId({toolchain_id})
      .toolTypeId("slack")
      .build();
   Response<ToolchainToolPost> response = toolchainService.createTool(createSlackToolOptions).execute();
   ToolchainToolPost slackTool = response.getResult();

variable "slack_webhook" {}
variable "slack_channel" {}
variable "slack_team" {}
data "ibm_resource_group" "rg" {
    name = "default"
}
resource "ibm_resource_instance" "kms" {
    name              = "my-kms-service-instance"
    service           = "kms"
    plan              = "tiered-pricing"
    location          = "us-south"
    resource_group_id = data.ibm_resource_group.rg.id
}
resource "ibm_kms_key" "key" {
    instance_id  = ibm_resource_instance.kms.guid
    key_name     = "my-slack-webhook"
    standard_key = true
    payload      = base64encode(var.slack_webhook)
}
resource "ibm_cd_toolchain" "toolchain" {
    name              = "tf-toolchain-secret-refs"
    resource_group_id = data.ibm_resource_group.rg.id
}
resource "ibm_iam_authorization_policy" "s2s" {
    source_service_name         = "toolchain"
    source_resource_instance_id = ibm_cd_toolchain.toolchain.id
    target_service_name         = "kms"
    target_resource_instance_id = ibm_resource_instance.kms.guid
    roles                       = ["Viewer", "ReaderPlus"]
}
resource "ibm_cd_toolchain_tool_keyprotect" "integration" {
    toolchain_id = ibm_cd_toolchain.toolchain.id
    parameters {
        name           = "my-kms-tool-integration"
        region         = var.region
        resource_group = data.ibm_resource_group.rg.name
        instance_name  = ibm_resource_instance.kms.name
    }
    depends_on = [
        ibm_iam_authorization_policy.s2s
    ]
}
resource "ibm_cd_toolchain_tool_slack" "integration" {
    toolchain_id = ibm_cd_toolchain.toolchain.id
    parameters {
        webhook      = "{vault::my-kms-tool-integration.my-slack-webhook}"
        channel_name = var.slack_channel
        team_name    = var.slack_team
    }
    depends_on = [
        ibm_cd_toolchain_tool_keyprotect.integration
        ibm_kms_key.key
    ]
}

variable "slack_webhook" {}
variable "slack_channel" {}
variable "slack_team" {}
variable "secrets_manager_name" {}
data "ibm_resource_group" "rg" {
    name = "default"
}
data ibm_resource_instance "sm" {
    name = var.secrets_manager_name
}
resource "ibm_sm_arbitrary_secret" "key" {
    instance_id     = data.ibm_resource_instance.sm.guid
    region          = data.ibm_resource_instance.sm.location
    secret_group_id = "default"
    name            = "my-slack-webhook"
    payload         = "var.slack_webhook"
}
resource "ibm_cd_toolchain" "toolchain" {
    name              = "tf-toolchain-secret-refs"
    resource_group_id = data.ibm_resource_group.rg.id
}
resource "ibm_iam_authorization_policy" "s2s" {
    source_service_name         = "toolchain"
    source_resource_instance_id = ibm_cd_toolchain.toolchain.id
    target_service_name         = "secrets-manager"
    target_resource_instance_id = data.ibm_resource_instance.sm.guid
    roles                       = ["Viewer", "SecretsReader"]
}
resource "ibm_cd_toolchain_tool_secretsmanager" "integration" {
    toolchain_id = ibm_cd_toolchain.toolchain.id
    parameters {
        name             = "my-sm-tool-integration"
        instance_id_type = "instance-crn"
        instance_crn     = data.ibm_resource_instance.sm.resource_crn
    }
    depends_on = [
        ibm_iam_authorization_policy.s2s
    ]
}
resource "ibm_cd_toolchain_tool_slack" "integration" {
    toolchain_id = ibm_cd_toolchain.toolchain.id
    parameters {
        webhook      = ibm_sm_arbitrary_secret.key.crn
        channel_name = var.slack_channel
        team_name    = var.slack_team
    }
    depends_on = [
        ibm_cd_toolchain_tool_secretsmanager.integration
    ]
}

Protection de vos données avec des clés gérées par le client

Par défaut, Continuous Delivery chiffre vos données à l'aide de clés internes au service Continuous Delivery. Pour plus de sécurité et de contrôle, vous pouvez configurer Continuous Delivery pour chiffrer vos données à l'aide de clés que vous gérez. Cette option est disponible uniquement dans le cadre du plan Professional et uniquement au moment où vous mettez à disposition une instance du service Continuous Delivery. Si vous choisissez votre propre service de gestion des clés, tel que Key Protect, IBM Cloud® ou Hyper Protect Crypto Services, les valeurs suivantes sont chiffrées à l’aide de votre propre clé plutôt qu’à l’aide des clés de chiffrement internes au service Continuous Delivery.

Les composants suivants chiffrent les données personnelles à l'aide de la clé de chiffrement gérée par le fournisseur.

Pour plus d'informations sur la création d'une instance de service Continuous Delivery qui chiffre les données avec une clé client, voir Création d'une instance de service Continuous Delivery.

Protection de vos données lorsque vous utilisez des intégrations d'outils tiers

Lorsque vous configurez une intégration d'outil pour une chaîne d'outils, vous activez explicitement le partage de données entre le service Continuous Delivery et l'intégration d'outil. Le type de données partagées, et si les données sont envoyées à l'outil, reçues de l'outil, ou les deux, varient en fonction du type d'intégration de l'outil.

Avant de configurer une intégration d'outil, assurez-vous de bien comprendre ce que sont les données partagées. Si vous travaillez avec des données ou des données réglementées que vous considérez sensibles, assurez-vous que l'utilisation de l'outil tiers et toutes les données qui peuvent être partagées avec elle ne compromettent pas la confidentialité, l'intégrité ou la disponibilité de vos ressources, ou enfreignent les contrôles réglementaires.

Pour en savoir plus sur les intégrations d'outils, voir Configuration des intégrations d'outil.

Protection de vos données lorsque vous utilisez Git Repos and Issue Tracking

Git Repos and Issue Tracking est un composant hébergé par IBMdu service Continuous Delivery. Toutes les données que vous fournissez à Git Repos and Issue Tracking, notamment les fichiers source, les problèmes, les demandes d'extraction et les propriétés de configuration de projet, sont gérées de manière sécurisée dans Continuous Delivery. Toutefois, Git Repos and Issue Tracking prend en charge différents mécanismes d'exportation, d'envoi ou de partage de données avec des utilisateurs et des tiers.

La capacité de Git Repos and Issue Tracking à partager des informations est typique de nombreuses plateformes de codage social. Toutefois, ce partage pourrait entrer en conflit avec les contrôles réglementaires applicables à votre entreprise. Une fois que vous avez créé un projet dans Git Repos and Issue Tracking, mais avant de charger des fichiers, des problèmes, des enregistrements ou d'autres données avec le projet, consultez les paramètres du projet et modifiez les paramètres que vous jugez nécessaires pour protéger vos données. Les paramètres à examiner incluent les niveaux de visibilité, les notifications par courrier électronique, les intégrations, les webhooks, les jetons d'accès, les jetons de déploiement et les clés de déploiement.

Protection de vos données lorsque vous utilisez des pipelines de distribution

Les pipelines Continuous Delivery exécutent les travaux et les étapes que vous fournissez. Le service Continuous Delivery gère en toute sécurité la sortie de journal et la génération des artefacts générés par vos exécutions de pipeline. Toutefois, Continuous Delivery ne limite ni ne gère la fonction de vos scripts de travaux de pipeline ou d'étapes.

Lorsque vous développez et configurez vos scripts de travaux et d'étapes de pipeline, assurez-vous que vos scripts n'exécutent pas d'actions susceptibles de compromettre la confidentialité, l'intégrité ou la disponibilité de vos ressources, ou d'enfreindre d'une autre manière les contrôles réglementaires.

Setting up authentication
API Key: ::add-mask::sk_live_abc123xyz
Using API key for requests
API response: {"key": "sk_live_abc123xyz", "status": "ok"}

Setting up authentication
API Key: ***
Using API key for requests
API response: {"key": "***", "status": "ok"}

Setting password ::add-mask::myP@ssw0rd
Setting token ::add-mask::ghp_abc123
Credentials: myP@ssw0rd, token: ghp_abc123

Setting password ***
Setting token ***
Credentials: ***, token: ***

Protéger vos données lorsque vous utilisez Terraform

Lorsque vous utilisez Terraform pour gérer des ressources Continuous Delivery, certaines des variables, arguments et attributs traités par Terraform peuvent contenir des valeurs secrètes telles que des mots de passe ou des jetons d'API. Ces valeurs peuvent être spécifiées par vous dans vos fichiers de langage de configuration Terraform, elles peuvent être extraites et stockées dans l'état Terraform par l'outil Terraform, ou les deux. La liste suivante fournit des exemples de valeurs de secret que vous devez protéger lorsque vous utilisez Terraform.

• Clé d'API IAM requise par le fournisseur Terraform IBM Cloud pour s'authentifier auprès de IBM Cloud. Cette clé est spécifiée dans l'argument ibmcloud_api_key du bloc provider "ibm" de votre module Terraform.
• Arguments ou attributs représentant des mots de passe, des jetons d'accès, des clés d'API ou d'autres types de secrets dans certaines ressources et sources de données ibm_cd_toolchain_tool.
• Valeurs de propriété désignées comme secrets dans certaines ressources ou sources de données ibm_cd_tekton_pipeline_property ou ibm_cd_tekton_pipeline_trigger_property.

Utilisez IBM Cloud Schematics et les pratiques suivantes pour limiter l'exposition des données sensibles:

• Utilisez des variables Terraform pour injecter des valeurs dans des blocs Terraform.
• Utilisez IBM Cloud Schematics pour gérer et partager des secrets en toute sécurité.
• Utilisez IBM Cloud Schematics pour gérer et partager en toute sécurité l'état Terraform.
• Utilisez les références de secrets Continuous Delivery lorsque vous spécifiez des secrets dans les ressources ibm_cd_toolchain_tool, ibm_cd_tekton_pipeline_property ou ibm_cd_tekton_pipeline_trigger_property.

Si vous utilisez l'outil de ligne de commande Terraform, utilisez les pratiques suivantes pour limiter l'exposition des données sensibles:

• Utilisez des variables Terraform pour injecter des valeurs dans des blocs Terraform.
• Autorisez l'outil de ligne de commande Terraform à demander des valeurs lorsque vous exécutez des commandes telles que terraform plan ou terraform apply.
• Contrôlez l'accès à votre état Terraform car il peut contenir des secrets. L'état Terraform local est écrit en texte clair.
• Utilisez les références de secrets Continuous Delivery lorsque vous spécifiez des secrets dans les ressources ibm_cd_toolchain_tool, ibm_cd_tekton_pipeline_property ou ibm_cd_tekton_pipeline_trigger_property.

Pour limiter l'exposition des données sensibles, évitez les pratiques suivantes:

• Ecriture de secrets en texte en clair dans des blocs Terraform, tels que des blocs de ressources, des blocs de données ou des blocs de fournisseur.
• Ecriture de secrets en texte en clair dans les fichiers terraform.tfvars, terraform.tfvars.json, *.auto.tfvars ou *.auto.tfvars.json.
• Distribution des fichiers terraform.tfvars, terraform.tfvars.json, *.auto.tfvars ou *.auto.tfvars.json qui contiennent des secrets dans des référentiels de code source.
• Distribution de votre état Terraform dans des référentiels de code source.

Utilisez IBM Cloud Schematics à la place de l'outil en ligne de commande Terraform pour traiter vos configurations Terraform. IBM Cloud Schematics offre plusieurs avantages, tels que le stockage sécurisé des propriétés de configuration sensibles.

Pour en savoir plus sur IBM Cloud Schematics, consultez la documentation relative à IBM Cloud Schematics.

Pour plus d'informations sur les données sensibles à l'état Terraform, voir Données sensibles à l'état.

Pour plus d'informations sur la définition des variables d'entrée dans Terraform, voir Affectation de valeurs à des variables de module racine.

Suppression de vos données de Continuous Delivery

Lorsque vous supprimez une instance de service Continuous Delivery, les chaînes d'outils, les intégrations d'outils, les outils et les données associés (y compris les données personnelles) ne sont pas supprimés. Pour plus d'informations sur la gestion et la suppression des données stockées avec les chaînes d'outils, les intégrations d'outils et les outils, voir Modification, exportation et suppression des données personnelles.