Protezione dei tuoi dati sensibili in Continuous Delivery

Il servizio Continuous Delivery crittografa i dati sensibili di proprietà del cliente prima di archiviarli nei database utilizzati internamente dal servizio. I dati sensibili includono i dati di configurazione dell'integrazione di strumenti di terze parti e i valori delle proprietà Delivery Pipeline. I dati vengono crittografati utilizzando le chiavi di crittografia interne per il servizio Continuous Delivery oppure utilizzando le chiavi di crittografia dalla chiave root specificata in un'istanza del servizio IBM® Key Protect for IBM Cloud® o dal servizio IBM Cloud® Hyper Protect Crypto Services.

I processi DevOps spesso richiedono diversi tipi di credenziali (come ad esempio i nomi utenti e le password, le chiavi API, le chiavi del servizio e le chiavi SSH) per interagire con altri sistemi per creare, verificare e distribuire applicazioni. È tua responsabilità garantire che tali credenziali non vengano inavvertitamente condivise fuori dall'ambito dei destinatari previsti. L'accesso a queste credenziali da parte di utenti malintenzionati potrebbe causare interruzioni delle tue operazioni IT e costi imprevisti oppure un utilizzo delle tue risorse per iniziare degli attacchi. IBM non è responsabile della protezione e del mantenimento della sicurezza delle tue credenziali.

Per mantenere al sicuro le tue credenziali, assicurati di attenerti alle seguenti indicazioni:

• Non memorizzare le credenziali in repository Git. A seconda delle impostazioni del repository, i file all'interno di un repository potrebbero essere visibili ad altri membri della tua organizzazione, ad altri utenti IBM Cloud o a internet pubblico.
• Non includere le credenziali utente nelle definizioni Delivery Pipeline perché potrebbero essere visibili ad altri utenti. In modo specifico, non mettere le credenziali utente all'interno degli script di definizione di lavori Delivery Pipeline Classic, file yaml Delivery Pipeline Tekton o script che sono avviati dalle delivery pipeline.
• Non pubblicare le credenziali utente nei file di log creati quando viene eseguita una pipeline perché questi file potrebbero essere condivisi.
• Non specificare le credenziali in testo semplice nelle chiamate alle API Continuous Delivery, come quando configuri le integrazioni dello strumento, le proprietà dell'ambiente della pipeline Tektono le proprietà del trigger della pipeline Tekton.
• Non includere credenziali, informazioni di identificazione personali o altre informazioni sensibili nelle chiamate all'API POST /toolchains/{toolchain_id}/events. L'API invia gli eventi contenenti i dati che specifichi alle istanze di Event Notifications che sono integrate nella toolchain. Event Notifications inoltrerà successivamente gli eventi alle destinazioni configurate come email, SMS e Slack.
• Non specificare le credenziali in testo semplice nei file di configurazione Terraform, ad esempio quando si definiscono le risorse di integrazione dello strumento, le risorse di proprietà dell'ambiente della pipeline Tekton o le risorse di proprietà del trigger della pipeline Tekton. Invece, gestisci le tue credenziali in un servizio di archiviazione dei segreti e specificale per riferimento nelle chiamate API e nelle configurazioni Terraform. Per ulteriori informazioni sulla gestione dei segreti per riferimento, vedi Protezione delle tue credenziali utilizzando i riferimenti segreti.

IBM Cloud fornisce diverse opzioni che puoi utilizzare per proteggere i segreti e l'archiviazione di chiavi.

• Proprietà dell'ambiente protetto della pipeline Classic
• Proprietà dell'ambiente protetto della pipeline Tekton
• IBM® Key Protect for IBM Cloud®
• IBM Cloud® Hyper Protect Crypto Services
• HashiCorp Vault

Per ulteriori informazioni sulle procedure ottimali DevOps, vedi DevOps Security.

Protezione delle tue credenziali utilizzando i riferimenti segreti

Molte delle proprietà che puoi configurare quando utilizzi le toolchain Continuous Delivery e le delivery pipeline, come password, chiavi API, certificati o altri token, sono classificate come segreti o credenziali. Per impostare il valore di una proprietà sicura, è possibile utilizzare un testo semplice o un riferimento segreto. L'uso di un riferimento ai segreti è il metodo consigliato per impostare il valore di una proprietà sicura.

Quando imposti una proprietà protetta con un testo semplice valore segreto, Continuous Delivery attivamente crittografa e memorizza il valore internamente. Sebbene il valore sia mantenuto protetto all'interno del servizio Continuous Delivery, il servizio non può proteggere il valore sul lato client. Quando imposti una proprietà protetta utilizzando la console nel tuo browser, richiamando un'API o configurando una risorsa Terraform, il segreto di testo semplice potrebbe essere esposto sui tuoi sistemi locali. Anche i segreti di testo semplice sono più difficili da ruotare. Quando un segreto, come ad esempio una chiave API, deve essere ruotato, anche tutte le proprietà sicure che portano il valore segreto devono essere localizzate e aggiornate.

Quando si imposta una proprietà sicura con un valore di riferimento ai segreti, il valore è una stringa appositamente formattata che fa riferimento alla posizione o all'indirizzo di un segreto gestito all'interno di un servizio di archiviazione dei segreti, ad esempio IBM® Key Protect for IBM Cloud®, IBM Cloud® Secrets Manager, o HashiCorp Vault. Sebbene Continuous Delivery codifichi e memorizzi attivamente il valore di riferimento dei segreti internamente, il valore del segreto non è esposto sul lato client. Quando Continuous Delivery deve richiamare il segreto per eseguire l'elaborazione per tuo conto, richiama internamente il valore dall'archivio dei segreti di riferimento. I riferimenti segreti sono anche resilienti alla rotazione. Generalmente, quando un segreto viene ruotato all'interno di un negozio di segreti, l'ubicazione o l'indirizzo del segreto rimane lo stesso. Viene modificato solo il valore segreto.

Sono supportati due tipi di riferimenti segreti: per nome o per CRN(Cloud Resource Name). Attualmente, solo le integrazioni dello strumento Secrets Manager supportano i segreti di riferimento tramite CRN. Questo formato consente una maggiore flessibilità perché puoi fare riferimento ai segreti da un'istanza Secrets Manager in un account diverso se è presente l'autorizzazione corretta.

Assicurati di considerare i seguenti prerequisiti per specificare un riferimento ai segreti all'interno dell'ambito di una toolchain:

• L'archivio dei segreti deve essere aggiunto alla toolchain come integrazione dello strumento. Per ulteriori informazioni sulle integrazioni degli strumenti di memorizzazione dei segreti, vedere Configurazione di Key Protect, Configurazione di Secrets Manager e Configurazione di HashiCorp Vault.
• È necessario configurare una politica di autorizzazione service - to - service IAM per consentire alla toolchain di origine di recuperare i segreti dall'archivio dei segreti di destinazione. Per ulteriori informazioni sulle autorizzazioni da servizio a servizio, vedi Utilizzo delle autorizzazioni per concedere l'accesso tra i servizi.

Quando lavori all'esterno della console, come con l'API o Terraform, utilizza il seguente formato per i riferimenti segreti in base al nome:

• {vault::SECRET_STORE_INTEGRATION_NAME.SECRET_NAME} quando fai riferimento ai segreti contenuti in Key Protect.
• {vault::SECRET_STORE_INTEGRATION_NAME.SECRET_GROUP_NAME.SECRET_NAME} quando fai riferimento a segreti contenuti in Secrets Manager.
• {vault::SECRET_STORE_INTEGRATION_NAME.SECRET_NAME.FIELD_NAME} quando si fa riferimento a segreti contenuti in HashiCorp Vault.

Valore segreto:

• ref://secrets-manager.REGION.RESOURCE-GROUP.SECRETS-MANAGER-INSTANCE-NAME1/SECRETS-GROUP-NAME/SECRET-NAME quando fai riferimento ai segreti contenuti in Key Protect.
• ref://secrets-manager.eu-de.EU-RG.SM-1/default/api-key quando fai riferimento a segreti contenuti in Secrets Manager.

Ad esempio, se il segreto riguarda il valore di una chiave, è possibile selezionare la chiave:

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

dove:

• SECRETS-MANAGER-INSTANCE-NAME1 è il nome dell'integrazione dell'archivio dei segreti nella toolchain, non il nome dell'istanza del servizio archivio dei segreti.
• SECRET_GROUP_NAME è il nome del gruppo che contiene il segreto all'interno di Secrets Manager.
• SECRET_NAME è il nome del segreto contenuto nell'archivio dei segreti.
• KEY_NAME è il nome della chiave nel segreto chiave-valore.

Per utilizzare un riferimento ai segreti CRN, ottenere il CRN segreto direttamente dall'IU Secrets Manager o in modo programmatico utilizzando la CLI, l'API o gli 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
    ]
}

Protezione dei dati con chiavi gestite dal cliente

Per impostazione predefinita, Continuous Delivery codifica i dati utilizzando le chiavi interne al servizio Continuous Delivery. Per una maggiore sicurezza e controllo, puoi configurare Continuous Delivery per crittografare i tuoi dati utilizzando le chiavi che gestisci. Questa opzione è disponibile solo nel piano Professional e solo al momento del provisioning di un'istanza del servizio Continuous Delivery. Se selezioni il tuo Key Management Service, come Key Protect o IBM Cloud® Hyper Protect Crypto Services, i seguenti valori vengono codificati utilizzando la tua chiave invece delle chiavi di crittografia interne al servizio Continuous Delivery.

I seguenti componenti codificano i dati personali utilizzando solo la chiave di crittografia gestita dal fornitore.

Per ulteriori informazioni sulla creazione di un'istanza del servizio Continuous Delivery che crittografa i dati con una chiave cliente, vedi Creazione di un'istanza del servizio Continuous Delivery.

Protezione dei dati quando si utilizzano integrazioni di strumenti di terze parti

Quando configuri un'integrazione dello strumento per una toolchain, abiliti esplicitamente la condivisione dei dati tra il servizio Continuous Delivery e l'integrazione dello strumento. Il tipo di dati condivisi e se i dati vengono inviati allo strumento, ricevuti dallo strumento o entrambi, variano a seconda del tipo di integrazione dello strumento.

Prima di configurare un'integrazione dello strumento, assicurati di comprendere quali dati sono condivisi. Se si utilizzano dati regolamentati o dati che si considerano sensibili, assicurarsi che l'utilizzo dello strumento di terze parti e i dati che potrebbero essere condivisi con esso non compromettano la riservatezza, l'integrità o la disponibilità delle risorse o violino in altro modo i controlli normativi.

Per ulteriori informazioni sulle integrazioni dello strumento, vedi Configurazione delle integrazioni dello strumento.

Protezione dei tuoi dati quando utilizzi Git Repos and Issue Tracking

Git Repos and Issue Tracking è un componente ospitato da IBMdel servizio Continuous Delivery. Tutti i dati forniti a Git Repos and Issue Tracking, inclusi, ma non limitati a file di origine, problemi, richieste di pull e proprietà di configurazione del progetto, sono gestiti in modo sicuro in Continuous Delivery. Tuttavia, Git Repos and Issue Tracking supporta vari meccanismi per l'esportazione, l'invio o la condivisione di dati a utenti e terze parti.

La capacità di Git Repos and Issue Tracking di condividere le informazioni è tipica di molte piattaforme di social coding. Tuttavia, tale condivisione potrebbe entrare in conflitto con i controlli normativi che si applicano alla tua azienda. Dopo aver creato un progetto in Git Repos and Issue Tracking, ma prima di affidare file, problemi, record o altri dati al progetto, riesamina le impostazioni del progetto e modifica tutte le impostazioni che ritieni necessarie per proteggere i tuoi dati. Le impostazioni da esaminare includono livelli di visibilità, notifiche email, integrazioni, hook web, token di accesso, token di distribuzione e chiavi di distribuzione.

Protezione dei dati quando si utilizza Delivery Pipelines

Continuous Delivery le pipeline eseguono i lavori e i passi che fornisci. Il servizio Continuous Delivery gestisce in modo sicuro l'output del log e le risorse di build prodotte dalle esecuzioni della tua pipeline. Tuttavia, Continuous Delivery non limita o gestisce la funzione del tuo lavoro della pipeline o degli script del passo.

Quando si sviluppano e configurano il lavoro della pipeline e gli script dei passi, assicurarsi che gli script non eseguano azioni che potrebbero compromettere la riservatezza, l'integrità o la disponibilità delle proprie risorse o violare in altro modo i controlli normativi.

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: ***

Proteggere i tuoi dati quando utilizzi Terraform

Quando utilizzi Terraform per gestire le risorse Continuous Delivery, alcune delle variabili, degli argomenti e degli attributi elaborati da Terraform potrebbero contenere valori segreti come password o token API. Questi valori potrebbero essere specificati dall'utente nei file della lingua di configurazione Terraform, potrebbero essere richiamati e memorizzati nello stato Terraform dallo strumento Terraform o da entrambi. Il seguente elenco fornisce esempi di valori segreti che devi proteggere quando utilizzi Terraform.

• La chiave API IAM che il provider di terraform IBM Cloud richiede per l'autenticazione in IBM Cloud. Questa chiave viene specificata nell'argomento ibmcloud_api_key del blocco provider "ibm" del tuo modulo Terraform.
• Gli argomenti o gli attributi che rappresentano le password, i token di accesso, le chiavi API o altri tipi di segreti in alcune risorse e origini dati ibm_cd_toolchain_tool.
• Valori di proprietà designati come segreti in alcune risorse o origini dati ibm_cd_tekton_pipeline_property o ibm_cd_tekton_pipeline_trigger_property.

Utilizza IBM Cloud Schematics e le seguenti prassi per limitare l'esposizione dei dati sensibili:

• Utilizzare le variabili Terraform per inserire valori nei blocchi Terraform.
• Utilizza IBM Cloud Schematics per gestire e condividere in modo sicuro i segreti.
• Utilizza IBM Cloud Schematics per gestire e condividere in modo sicuro lo stato Terraform.
• Utilizza i riferimenti segreti Continuous Delivery quando specifichi i segreti all'interno delle risorse ibm_cd_toolchain_tool, ibm_cd_tekton_pipeline_property o ibm_cd_tekton_pipeline_trigger_property.

Se si utilizza lo strumento della riga comandi Terraform, utilizzare le seguenti procedure per limitare l'esposizione dei dati sensibili:

• Utilizzare le variabili Terraform per inserire valori nei blocchi Terraform.
• Consenti allo strumento della riga di comando Terraform di richiedere i valori quando esegui comandi come terraform plan o terraform apply.
• Controlla l'accesso al tuo stato Terraform poiché potrebbe contenere segreti. Lo stato Terraform locale è scritto in testo semplice.
• Utilizza i riferimenti segreti Continuous Delivery quando specifichi i segreti all'interno delle risorse ibm_cd_toolchain_tool, ibm_cd_tekton_pipeline_property o ibm_cd_tekton_pipeline_trigger_property.

Per limitare l'esposizione dei dati sensibili, evitare le seguenti pratiche:

• Scrittura di segreti in testo semplice all'interno di blocchi Terraform, come blocchi di risorse, blocchi di dati o blocchi di provider.
• Scrittura dei segreti in testo semplice all'interno dei file terraform.tfvars, terraform.tfvars.json, *.auto.tfvars o *.auto.tfvars.json.
• Consegna dei file terraform.tfvars, terraform.tfvars.json, *.auto.tfvars o *.auto.tfvars.json che contengono segreti ai repository del codice sorgente.
• Consegna del tuo stato Terraform nei repository del codice sorgente.

Utilizza IBM Cloud Schematics anziché lo strumento da riga di comando Terraform per elaborare le tue configurazioni Terraform. IBM Cloud Schematics offre diversi vantaggi, come l'archiviazione sicura delle proprietà di configurazione sensibili.

Per ulteriori informazioni su IBM Cloud Schematics, vedi la documentazione IBM Cloud Schematics.

Per ulteriori informazioni sui dati sensibili nello stato Terraform, vedi Dati sensibili nello stato.

Per ulteriori informazioni su come impostare le variabili di input in Terraform, consulta Assegnazione di valori alle variabili del modulo root.

Eliminazione dei tuoi dati da Continuous Delivery

Quando elimini un'istanza del servizio Continuous Delivery, le toolchain, le integrazioni di strumenti, gli strumenti e i dati correlati (compresi i dati personali) non vengono eliminati. Per ulteriori informazioni su come gestire ed eliminare i dati archiviati con toolchain, integrazioni di strumenti e strumenti, vedi Modifica, esplorazione ed eliminazione dei dati personali.