Protegendo os seus dados sensíveis no Continuous Delivery

O serviço Continuous Delivery criptografa os dados sensíveis de propriedade do cliente antes de armazená-los em bancos de dados que são usados internamente pelo serviço. Os dados sensíveis incluem os dados de configuração da integração de ferramenta de terceiros e os valores de propriedade do Delivery Pipeline. Os dados são criptografados por meio de chaves de criptografia internas ao serviço Continuous Delivery ou por meio de chaves de criptografia derivadas da chave raiz especificada em uma instância do serviço IBM® Key Protect for IBM Cloud® ou do serviço IBM Cloud® Hyper Protect Crypto Services.

Os processos do DevOps geralmente requerem que vários tipos de credenciais (como nomes de usuário e senhas, chaves de API, chaves de serviço e chaves SSH) interajam com outros sistemas para construir, testar e implementar aplicativos. Você é responsável por assegurar que essas credenciais não sejam compartilhadas acidentalmente com pessoas que não estejam dentro do seu público desejado. O acesso a essas credenciais por agentes maliciosos pode interromper as suas operações de TI, causar custos inesperados ou usar seus recursos para iniciar ataques. A IBM não é responsável por proteger e manter a segurança de suas credenciais.

Para manter suas credenciais seguras, certifique-se de seguir estas orientações:

• Não armazene credenciais nos repositórios Git. Dependendo das configurações do repositório, os arquivos de um repositório podem ficar visíveis para outros membros de sua organização, outros usuários do IBM Cloud ou para a Internet pública.
• Não inclua credenciais do usuário em definições do Delivery Pipeline, pois elas podem ficar visíveis para outros usuários. Especificamente, não coloque credenciais do usuário dentro de scripts de definição de tarefa do Delivery Pipeline Classic, de arquivos yaml de Tekton do Delivery Pipeline ou de scripts iniciados por pipelines de entrega.
• Não publique credenciais do usuário em arquivos de log que são criados quando um pipeline é executado, pois esses arquivos podem ser compartilhados.
• Não especifique credenciais em texto simples em chamadas para Continuous Delivery APIs, como quando você configura integrações de ferramentas, Propriedades do ambiente de pipeline do Tekton pipelineou Propriedades do gatilho do pipeline de Tekton.
• Não inclua credenciais, informações de identificação pessoal ou outras informações confidenciais em chamadas para a API POST /toolchains/{toolchain_id}/events A API envia eventos que contêm os dados especificados para instâncias do Event Notifications que são integradas na cadeia de ferramentas. Event Notifications encaminhará subsequentemente os eventos para destinos configurados, como e-mail, SMS e Slack.
• Não especifique credenciais em texto simples em arquivos de configuração Terraform, como quando você define recursos de integração de ferramentas, recursos de propriedade do ambiente de pipeline do Tekton ou pipeline de Tekton acionam recursos de propriedade. Em vez disso, gerencie credenciais em um serviço de armazenamento de segredos e especifique-as por referência em chamadas API e configurações de Terraform. Para obter mais informações sobre o gerenciamento de segredos por referência, consulte Protegendo suas credenciais usando referências de segredos.

O IBM Cloud fornece várias opções que podem ser usadas para proteger os segredos e o armazenamento de chaves.

• Propriedades do ambiente seguro do pipeline clássico
• Propriedades do ambiente seguro do pipeline Tekton
• IBM® Key Protect for IBM Cloud®
• IBM Cloud® Hyper Protect Crypto Services
• HashiCorp Vault

Para obter mais informações sobre as melhores práticas seguras DevOps, consulte DevOps Security.

Protegendo suas credenciais usando referências de segredos

Muitas das propriedades que você pode configurar quando estiver trabalhando com Continuous Delivery as cadeias de ferramentas e os pipelines de entrega, como senhas, chaves de API, certificados ou outros tokens, são classificados como segredos ou credenciais. Para configurar o valor de uma propriedade segura, você pode usar texto simples ou uma referência de segredos. Usar uma referência de segredos é o método recomendado para configurar o valor de uma propriedade segura.

Quando você configura uma propriedade segura com um valor secreto texto simples, Continuous Delivery ativamente criptografa e armazena o valor internamente. Apesar de o valor ser mantido seguro dentro do serviço Continuous Delivery, o serviço não pode proteger o valor no lado do cliente. Quando você configura uma propriedade segura usando o console em seu navegador, chamando uma API, ou configurando um recurso Terraform, o segredo de texto simples pode estar exposto em seus sistemas locais. Segredos de texto simples também são mais difíceis de rodar. Quando um segredo, como uma chave API, deve ser rotacionado, todas as propriedades seguras que carregam o valor secreto também devem estar localizadas e atualizadas.

Quando você define uma propriedade segura com um valor de referência de segredos, o valor é uma cadeia de caracteres especialmente formatada que se refere ao local ou endereço de um segredo gerenciado em um serviço de armazenamento de segredos, como IBM® Key Protect for IBM Cloud®, IBM Cloud® Secrets Manager, ou HashiCorp Vault. Apesar de Continuous Delivery criptografar ativamente e armazenar o valor de referência de segredos internamente, o valor secreto não é exposto no lado do cliente. Quando Continuous Delivery deve recuperar o segredo para realizar o processamento em seu nome, ele recupera internamente o valor da loja de segredos referenciados. As referências de segredos também são resistentes à rotação. Geralmente, quando um segredo é rodado dentro de uma loja de segredos, o local ou endereço do segredo permanece o mesmo. Apenas o valor secreto em si é alterado.

Dois tipos de referências de segredos são suportados: por nome ou por Cloud Resource Name(CRN). Atualmente, apenas as integrações de ferramenta Secrets Manager suportam a referência de segredos por CRN. Esse formato permite maior flexibilidade porque é possível referenciar segredos de uma instância Secrets Manager em uma conta diferente se a autorização correta estiver em vigor.

Certise-se de considerar os seguintes pré-requisitos para especificação de uma referência de segredos dentro do escopo de uma cadeia de ferramentas:

• A loja de segredos deve ser adicionada à cadeia de ferramentas como uma integração de ferramentas. Para obter mais informações sobre integrações de ferramentas de armazenamento de segredos, consulte Configurando Key Protect, Configurando Secrets Manager e Configurando HashiCorp Vault.
• Uma política de autorização de serviço de serviço IAM deve ser configurada para permitir que a cadeia de ferramentas de origem recupere segredos da loja de segredos de destino. Para obter mais informações sobre autorizações de serviço para atendimento, consulte Usando autorizações para conceder acesso entre serviços.

Ao trabalhar fora do console, como com a API ou o Terraform, use o formato a seguir para referências de segredos por nome:

• {vault::SECRET_STORE_INTEGRATION_NAME.SECRET_NAME} quando você referencia segredos que estão contidos dentro de Key Protect.
• {vault::SECRET_STORE_INTEGRATION_NAME.SECRET_GROUP_NAME.SECRET_NAME} quando você referencia segredos que estão contidos dentro de Secrets Manager.
• {vault::SECRET_STORE_INTEGRATION_NAME.SECRET_NAME.FIELD_NAME} quando você faz referência a segredos contidos em HashiCorp Vault.

Valor secreto:

• ref://secrets-manager.REGION.RESOURCE-GROUP.SECRETS-MANAGER-INSTANCE-NAME1/SECRETS-GROUP-NAME/SECRET-NAME quando você referencia segredos que estão contidos dentro de Key Protect.
• ref://secrets-manager.eu-de.EU-RG.SM-1/default/api-key quando você referencia segredos que estão contidos dentro de Secrets Manager.

Por exemplo, se o segredo for de um valor de chave, você poderá selecionar a chave:

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

em que:

• SECRETS-MANAGER-INSTANCE-NAME1 é o nome dos segredos armazenam integração na cadeia de ferramentas, não o nome da instância de serviço de armazenamento de segredos.
• SECRET_GROUP_NAME é o nome do grupo que contém o segredo dentro de Secrets Manager.
• SECRET_NAME é o nome do segredo no repositório de segredos.
• KEY_NAME é o nome da chave no segredo de valor-chave.

Para usar uma referência de segredos do CRN, obtenha o CRN secreto diretamente da IU do Secrets Manager ou programaticamente usando a CLI, a API ou os SDKs.

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
    ]
}

Protegendo seus dados com chaves gerenciadas pelo cliente

Por padrão, Continuous Delivery criptografa seus dados usando chaves que são internas para o serviço Continuous Delivery. Para maior segurança e controle, você pode configurar Continuous Delivery para criptografar seus dados usando chaves que você gerencia. Esta opção está disponível apenas sob o plano Professional, e somente no momento em que você estiver provisionando uma instância do serviço Continuous Delivery. Se você selecionar seu próprio Serviço de Gerenciamento de Chaves, como Key Protect, IBM Cloud® ou Hyper Protect Crypto Services, os valores a seguir serão criptografados usando sua própria chave, em vez das chaves de criptografia internas ao serviço Continuous Delivery.

Os componentes a seguir criptografam dados pessoais usando apenas a chave de criptografia gerenciada pelo provedor.

Para obter mais informações sobre a criação de uma instância de serviço Continuous Delivery que criptografa dados com uma chave do cliente, consulte Criando uma instância de serviço Continuous Delivery.

Protegendo seus dados ao usar integrações de ferramentas de terceiros

Ao configurar uma integração de ferramentas para uma cadeia de ferramentas, você permite explicitamente o compartilhamento de dados entre o serviço Continuous Delivery e a integração de ferramenta. O tipo de dado que é compartilhado e se os dados são enviados para a ferramenta, recebidos da ferramenta, ou ambos, varia dependendo do tipo de integração de ferramenta.

Antes de configurar uma integração de ferramenta, certifique-se de entender quais dados são compartilhados. Se você trabalha com dados regulados ou dados que considera sensíveis, certifique-se de que o uso da ferramenta de terceiro e quaisquer dados que possam ser compartilhados com ela não comprometam a confidencialidade, a integridade ou a disponibilidade de seus recursos, ou de outra forma violem os controles regulamentares.

Para saber mais sobre integrações de ferramenta, consulte Configurando integrações de ferramenta.

Protegendo seus dados ao usar Git Repos and Issue Tracking

Git Repos and Issue Tracking é um componente hospedado IBM do serviço Continuous Delivery. Todos os dados que você fornecer para Git Repos and Issue Tracking, incluindo mas não se limitando a arquivos de origem, problemas, solicitações pull e propriedades de configuração do projeto, são gerenciados de forma segura dentro do Continuous Delivery. No entanto, o Git Repos and Issue Tracking suporta vários mecanismos para exportação, envio ou compartilhamento de dados para usuários e terceiros.

A capacidade do Git Repos and Issue Tracking em compartilhar informações é típica de muitas plataformas de codificação social. No entanto, esse compartilhamento pode entrar em conflito com as normas regulatórias aplicáveis à sua empresa. Depois de criar um projeto em Git Repos and Issue Tracking, mas antes de confiar em quaisquer arquivos, problemas, registros ou outros dados com o projeto, revise as configurações do projeto e mude quaisquer configurações que julgar necessárias para proteger seus dados. As configurações para revisão incluem níveis de visibilidade, notificações por e-mail, integrações, webhooks, tokens de acesso, tokens de implementação e chaves de implementação.

Protegendo seus dados ao usar pipelines de entrega

Os pipelines Continuous Delivery executam as tarefas e etapas que você fornece. O serviço Continuous Delivery gerencia com segurança a saída do log e cria artefatos que são produzidos por suas execuções de pipeline. No entanto, o Continuous Delivery não limita ou gerencia a função de sua tarefa de pipeline ou scripts de etapa.

Ao desenvolver e configurar seus scripts de tarefa e etapa de pipeline, certifique-se de que seus scripts não executam ações que possam comprometer a confidencialidade, a integridade ou a disponibilidade de seus recursos, ou de outra forma violar os controles regulamentares.

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

Protegendo seus dados ao usar o Terraform

Quando você usa Terraform para gerenciar Continuous Delivery recursos, algumas das variáveis, argumentos e atributos que são processados por Terraform podem carregar valores secretos como senhas ou tokens de API. Esses valores podem ser especificados por você em seus arquivos de linguagem de configuração Terraform, eles podem ser recuperados e armazenados no estado Terraform pela ferramenta Terraform, ou ambos. A lista a seguir fornece exemplos de valores secretos que você deve proteger quando usar Terraform.

• A Chave API do IAM que o Provedor IBM Cloud Terraform Provider requer para autenticar para o IBM Cloud. Esta chave é especificada no argumento ibmcloud_api_key do bloco provider "ibm" do seu módulo Terraform.
• Os argumentos ou atributos que representam senhas, tokens de acesso, chaves API ou outros tipos de segredos em alguns recursos ibm_cd_toolchain_tool e fontes de dados.
• Valores de propriedade que são designados como segredos em alguns recursos ibm_cd_tekton_pipeline_property ou ibm_cd_tekton_pipeline_trigger_property ou fontes de dados.

Use IBM Cloud Schematics e as práticas a seguir para limitar a exposição de dados sensíveis:

• Use variáveis Terraform para injetar valores em blocos Terraform.
• Use IBM Cloud Schematics para gerenciar de forma segura e compartilhar segredos.
• Use IBM Cloud Schematics para gerenciar de forma segura e compartilhar o estado Terraform.
• Use as referências de segredos Continuous Delivery quando você especificar segredos dentro dos recursos ibm_cd_toolchain_tool, ibm_cd_tekton_pipeline_property ou ibm_cd_tekton_pipeline_trigger_property.

Se você estiver usando a ferramenta de linha de comandos Terraform, use as seguintes práticas para limitar a exposição de dados sensíveis:

• Use variáveis Terraform para injetar valores em blocos Terraform.
• Permitir que a ferramenta de linha de comandos Terraform solicite valores quando você executar comandos como terraform plan ou terraform apply.
• Controle o acesso ao seu estado Terraforma desde que ele possa conter segredos. O estado Terraforme local é escrito em texto simples.
• Use as referências de segredos Continuous Delivery quando você especificar segredos dentro dos recursos ibm_cd_toolchain_tool, ibm_cd_tekton_pipeline_property ou ibm_cd_tekton_pipeline_trigger_property.

Para limitar a exposição de dados sensíveis, evite as seguintes práticas:

• Escrever segredos em texto simples dentro de quaisquer blocos Terraformar, como blocos de recursos, blocos de dados ou blocos de provedores.
• Gravação de segredos em texto simples dentro dos arquivos terraform.tfvars, terraform.tfvars.json, *.auto.tfvars ou *.auto.tfvars.json.
• Entregando os arquivos terraform.tfvars, terraform.tfvars.json, *.auto.tfvars ou *.auto.tfvars.json que contêm segredos para repos de código fonte.
• Entregando seu estado Terraform em repos de código fonte.

Use IBM Cloud Schematics em vez da ferramenta de linha de comando Terraform para processar suas configurações Terraform. IBM Cloud Schematics oferece várias vantagens, como armazenamento seguro de propriedades de configuração confidenciais.

Para obter mais informações sobre o IBM Cloud Schematics, consulte a documentação do IBM Cloud Schematics.

Para obter mais informações sobre dados sensíveis no estado Terraform, consulte Dados Sensíveis no Estado.

Para obter mais informações sobre como configurar variáveis de entrada em Terraform, consulte Atribuindo Valores a Variáveis do Módulo Raiz.

Excluindo os seus dados do Continuous Delivery

Ao excluir uma instância de serviço do Continuous Delivery, as cadeias de ferramentas, as integrações de ferramenta, as ferramentas e os dados relacionados (incluindo os dados pessoais) não são excluídos. Para obter mais informações sobre como gerenciar e excluir dados que são armazenados com cadeias de ferramentas, integrações de ferramenta e ferramentas, consulte Modificando, explorando e excluindo os dados pessoais.