Protección de los datos confidenciales en Continuous Delivery

El servicio Continuous Delivery cifra los datos confidenciales propiedad del cliente antes de guardarlos en las bases de datos que el servicio utiliza internamente. Los datos confidenciales incluyen datos de configuración de integración de herramientas de terceros y valores de propiedades de Delivery Pipeline. Los datos se cifran utilizando claves de cifrado internas del servicio Continuous Delivery o mediante claves de cifrado derivadas de la clave raíz especificada en una instancia del servicio IBM® Key Protect for IBM Cloud® o del servicio IBM Cloud® Hyper Protect Crypto Services.

Los procesos de DevOps a menudo requieren diversos tipos de credenciales (como, por ejemplo, nombres de usuario y contraseñas, claves de API, claves de servicios y claves SSH) para interactuar con otros sistemas con el fin de crear, probar y desplegar aplicaciones. El usuario es el responsable de garantizar que estas credenciales no se compartan de forma involuntaria fuera de su público destinatario. El acceso a estas credenciales por parte de agentes malintencionados puede interrumpir las operaciones de TI, provocar costes inesperados o utilizar los recursos para iniciar ataques. IBM no se hace responsable de la protección y el mantenimiento de la seguridad de sus credenciales.

Para mantener seguras sus credenciales, asegúrese de seguir estas directrices:

• No almacene credenciales en repositorios Git. Según los valores de los repositorios, puede que los archivos dentro de un repositorio estén visibles para otros miembros de su organización distintos de los usuarios de IBM Cloud o la Internet pública.
• No incluya las credenciales de usuario en las definiciones de Delivery Pipeline porque es posible que sean visibles para otros usuarios. Específicamente, no ponga las credenciales de usuario en scripts de definiciones de trabajos clásicos de Delivery Pipeline, en archivos yaml de Delivery Pipeline Tekton o en scripts que se inicien mediante los conductos de entrega.
• No publique las credenciales de usuario en los archivos de registro que se crean cuando se ejecuta un conducto porque estos archivos pueden compartirse.
• No especifique credenciales en texto sin formato en las llamadas a las API Continuous Delivery, como cuando configure las integraciones de herramientas, propiedades de entorno de interconexión de Tektono propiedades de desencadenante de interconexión de Tekton.
• No incluya credenciales, información de identificación personal u otra información confidencial en las llamadas a la API POST /toolchains/{toolchain_id}/events. La API envía sucesos que contienen los datos que especifique a instancias de Event Notifications que están integradas en la cadena de herramientas. Event Notifications reenviará posteriormente los sucesos a destinos configurados como, por ejemplo, correo electrónico, SMS y Slack.
• No especifique credenciales en texto sin formato en los archivos de configuración de Terraform, como cuando defina recursos de integración de herramientas, recursos de propiedad de entorno de interconexión de Tekton o recursos de propiedad de desencadenante de interconexión de Tekton. En su lugar, gestione las credenciales en un servicio de almacenamiento de secretos y especifíquelas por referencia en las llamadas de API y las configuraciones de Terraform. Para obtener más información sobre la gestión de secretos por referencia, consulte Protección de las credenciales utilizando referencias de secretos.

IBM Cloud proporciona varias opciones que puede utilizar para el almacenamiento de claves seguras y guardarlas en secreto.

• Propiedades de entorno seguro de conductos clásicos
• Propiedades de entorno seguro de conductos Tekton
• IBM® Key Protect for IBM Cloud®
• IBM Cloud® Hyper Protect Crypto Services
• HashiCorp Vault

Para obtener más información sobre las prácticas recomendadas de DevOps seguras, consulte Seguridad deDevOps.

Protección de las credenciales utilizando referencias de secretos

Muchas de las propiedades que puede configurar al trabajar con Continuous Delivery cadenas de herramientas y conductos de entrega, como contraseñas, claves de API, certificados u otras señales, se clasifican como secretos o credenciales. Para establecer el valor de una propiedad segura, puede utilizar texto sin formato o una referencia de secretos. El uso de una referencia de secretos es el método recomendado para establecer el valor de una propiedad segura.

Cuando establece una propiedad segura con un valor de secreto de texto sin formato, Continuous Delivery cifra y almacena el valor de forma activa internamente. Aunque el valor se mantiene seguro dentro del servicio Continuous Delivery, el servicio no puede proteger el valor en el lado del cliente. Cuando establece una propiedad segura utilizando la consola en el navegador, llamando a una API o configurando un recurso de Terraform, el secreto de texto sin formato puede estar expuesto en los sistemas locales. Los secretos de texto sin formato también son más difíciles de rotar. Cuando se debe rotar un secreto, como una clave de API, también se deben localizar y actualizar todas las propiedades seguras que conllevan el valor de secreto.

Cuando establece una propiedad segura con un valor de referencia de secretos, el valor es una cadena con un formato especial que hace referencia a la ubicación o dirección de un secreto que se gestiona dentro de un servicio de almacenamiento de secretos como IBM® Key Protect for IBM Cloud®, IBM Cloud® Secrets Manager o HashiCorp Vault. Aunque Continuous Delivery cifra y almacena de forma activa el valor de referencia de secretos internamente, el valor de secreto no se expone en el lado del cliente. Cuando Continuous Delivery debe recuperar el secreto para realizar el proceso en su nombre, recupera internamente el valor del almacén de secretos referenciado. Las referencias de secretos también son resistentes a la rotación. Normalmente, cuando un secreto se rota dentro de un almacén de secretos, la ubicación o dirección del secreto permanece igual. Sólo se cambia el propio valor secreto.

Se admiten dos tipos de referencias de secretos: por nombre o por Nombre de recurso de nube(CRN). Actualmente, solo las integraciones de herramientas de Secrets Manager dan soporte a la referencia de secretos por CRN. Este formato permite una mayor flexibilidad porque puede hacer referencia a secretos de una instancia de Secrets Manager en una cuenta diferente si existe la autorización correcta.

Asegúrese de que tiene en cuenta los siguientes requisitos previos para especificar una referencia de secretos dentro del ámbito de una cadena de herramientas:

• El almacén de secretos debe añadirse a la cadena de herramientas como integración de herramientas. Para obtener más información sobre las integraciones de herramientas de almacenamiento de secretos, consulte Configuración de Key Protect, Configuración de Secrets Manager y Configuración de HashiCorp Vault.
• Se debe configurar una política de autorización de servicio a servicio de IAM para permitir que la cadena de herramientas de origen recupere secretos del almacén de secretos de destino. Para obtener más información sobre las autorizaciones de servicio a servicio, consulte Utilización de autorizaciones para otorgar acceso entre servicios.

Cuando trabaje fuera de la consola, como por ejemplo con la API o Terraform, utilice el formato siguiente para las referencias de secretos por nombre:

• {vault::SECRET_STORE_INTEGRATION_NAME.SECRET_NAME} cuando hace referencia a secretos contenidos en Key Protect.
• {vault::SECRET_STORE_INTEGRATION_NAME.SECRET_GROUP_NAME.SECRET_NAME} cuando hace referencia a secretos contenidos en Secrets Manager.
• {vault::SECRET_STORE_INTEGRATION_NAME.SECRET_NAME.FIELD_NAME} cuando se hace referencia a secretos contenidos en HashiCorp Vault.

Valor secreto:

• ref://secrets-manager.REGION.RESOURCE-GROUP.SECRETS-MANAGER-INSTANCE-NAME1/SECRETS-GROUP-NAME/SECRET-NAME cuando hace referencia a secretos contenidos en Key Protect.
• ref://secrets-manager.eu-de.EU-RG.SM-1/default/api-key cuando hace referencia a secretos contenidos en Secrets Manager.

Por ejemplo, si el secreto es de un valor clave, puede seleccionar la clave:

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

donde:

• SECRETS-MANAGER-INSTANCE-NAME1 es el nombre de la integración de almacén de secretos en la cadena de herramientas, no el nombre de la instancia de servicio de almacén de secretos.
• SECRET_GROUP_NAME es el nombre del grupo que contiene el secreto en Secrets Manager.
• SECRET_NAME es el nombre del secreto en el almacén de secretos.
• KEY_NAME es el nombre de la clave en el secreto clave-valor.

Para utilizar una referencia de secretos de CRN, obtenga el CRN secreto directamente desde la interfaz de usuario de Secrets Manager o mediante programación utilizando la CLI, la API o los 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
    ]
}

Protección de los datos con claves gestionadas por el cliente

De forma predeterminada, Continuous Delivery cifra los datos utilizando claves internas para el servicio Continuous Delivery. Para una mayor seguridad y control, puede configurar Continuous Delivery para cifrar los datos utilizando las claves que gestiona. Esta opción sólo está disponible bajo el plan Profesional y sólo en el momento en que está suministrando una instancia del servicio Continuous Delivery. Si selecciona su propio servicio de gestión de claves, como Key Protect, IBM Cloud® o Hyper Protect Crypto Services, los siguientes valores se cifran utilizando su propia clave en lugar de las claves de cifrado internas del servicio Continuous Delivery.

Los siguientes componentes cifran los datos personales utilizando solo la clave de cifrado gestionada por el proveedor.

Para obtener más información sobre cómo crear una instancia de servicio de Continuous Delivery que cifre los datos con una clave de cliente, consulte Creación de una instancia de servicio de Continuous Delivery.

Protección de datos cuando se utilizan integraciones de herramientas de terceros

Cuando configura una integración de herramientas para una cadena de herramientas, habilita explícitamente el compartimiento de datos entre el servicio de Continuous Delivery y la integración de herramientas. El tipo de datos que se comparte y si los datos se envían a la herramienta, se reciben desde la herramienta o ambos variará en función del tipo de integración de la herramienta.

Antes de configurar una integración de herramientas, asegúrese de que sabe qué datos se comparten. Si trabaja con datos regulados o con datos que considera confidenciales, asegúrese de que el uso de la herramienta de terceros y los datos que se puedan compartir con ella no pongan en peligro la confidencialidad, la integridad o la disponibilidad de sus recursos, ni infrinjan de otro modo los controles normativos.

Para obtener más información sobre las integraciones de herramientas, consulte Configurar integraciones de herramientas.

Protección de los datos cuando utiliza Git Repos and Issue Tracking

Git Repos and Issue Tracking es un componente alojado en IBM del servicio de Continuous Delivery. Todos los datos que se proporcionan a Git Repos and Issue Tracking, incluidos los archivos de origen, los problemas, las solicitudes de extracción y las propiedades de configuración del proyecto se gestionan de forma segura en Continuous Delivery. Sin embargo, Git Repos and Issue Tracking da soporte a varios mecanismos para exportar, enviar o compartir de otro modo datos con usuarios y terceros.

La capacidad de Git Repos and Issue Tracking de compartir información es típica de muchas plataformas de codificación social. Sin embargo, dicho intercambio podría entrar en conflicto con los controles normativos que se aplican a su empresa. Después de crear un proyecto en Git Repos and Issue Tracking, pero antes de confiar archivos, problemas, registros u otros datos con el proyecto, revise la configuración del proyecto y cambie los valores que considere necesarios para proteger los datos. Los valores que se deben revisar incluyen niveles de visibilidad, notificaciones de correo electrónico, integraciones, webhooks, señales de acceso, señales de despliegue y claves de despliegue.

Protección de los datos cuando se utilizan Interconexiones de entrega

Las interconexiones de Continuous Delivery ejecutan los trabajos y los pasos que proporciona. El servicio de Continuous Delivery gestiona de forma segura la salida del registro y los artefactos de compilación generados por las ejecuciones de la interconexión. Sin embargo, Continuous Delivery no limita ni gestiona la función de los scripts de paso o trabajo de interconexión.

Cuando desarrolle y configure los scripts de pasos y trabajos de interconexión, asegúrese de que los scripts no ejecuten acciones que puedan poner en peligro la confidencialidad, la integridad o la disponibilidad de sus recursos, ni que infrinjan de otro modo los controles normativos.

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

Cómo proteger tus datos al utilizar Terraform

Cuando se utiliza Terraform para gestionar recursos de Continuous Delivery, algunas de las variables, argumentos y atributos procesados por Terraform pueden llevar valores secretos como contraseñas o señales de API. Estos valores pueden ser especificados por el usuario en los archivos de idioma de configuración de Terraform, pueden ser recuperados y almacenados en estado de Terraform por la herramienta de Terraform, o ambos. La lista siguiente proporciona ejemplos de valores secretos que debe proteger cuando utilice Terraform.

• La clave de API de IAM que el proveedor de Terraform IBM Cloud requiere para autenticarse en IBM Cloud. Esta clave se especifica en el argumento ibmcloud_api_key del bloque provider "ibm" del módulo Terraform.
• Los argumentos o atributos que representan contraseñas, señales de acceso, claves de API u otros tipos de secretos en algunos recursos y orígenes de datos de ibm_cd_toolchain_tool.
• Valores de propiedad que se designan como secretos en algunos recursos u orígenes de datos de ibm_cd_tekton_pipeline_property o ibm_cd_tekton_pipeline_trigger_property.

Utilice IBM Cloud Schematics y las prácticas siguientes para limitar la exposición de datos confidenciales:

• Utilice variables de Terraform para inyectar valores en bloques de Terraform.
• Utilice IBM Cloud Schematics para gestionar y compartir secretos de forma segura.
• Utilice IBM Cloud Schematics para gestionar y compartir de forma segura el estado de Terraform.
• Utilice las referencias de secretos Continuous Delivery cuando especifique secretos dentro de los recursos ibm_cd_toolchain_tool, ibm_cd_tekton_pipeline_property o ibm_cd_tekton_pipeline_trigger_property.

Si está utilizando la herramienta de línea de mandatos de Terraform, utilice las prácticas siguientes para limitar la exposición de datos confidenciales:

• Utilice variables de Terraform para inyectar valores en bloques de Terraform.
• Permita que la herramienta de línea de mandatos de Terraform solicite valores al ejecutar mandatos como terraform plan o terraform apply.
• Controle el acceso al estado de Terraform, ya que puede contener secretos. El estado local de Terraform se escribe en texto sin formato.
• Utilice las referencias de secretos Continuous Delivery cuando especifique secretos dentro de los recursos ibm_cd_toolchain_tool, ibm_cd_tekton_pipeline_property o ibm_cd_tekton_pipeline_trigger_property.

Para limitar la exposición de datos confidenciales, evite las prácticas siguientes:

• Escribir secretos en texto sin formato dentro de cualquier bloque de Terraform, como bloques de recursos, bloques de datos o bloques de proveedor.
• Escribir secretos en texto sin formato dentro de los archivos terraform.tfvars, terraform.tfvars.json, *.auto.tfvars o *.auto.tfvars.json.
• Entrega de los archivos terraform.tfvars, terraform.tfvars.json, *.auto.tfvars o *.auto.tfvars.json que contienen secretos a repositorios de código fuente.
• Entrega del estado de Terraform en repositorios de código fuente.

Utilice IBM Cloud Schematics en lugar de la herramienta comando línea de comandos Terraform para procesar sus configuraciones Terraform. IBM Cloud Schematics ofrece varias ventajas, como el almacenamiento seguro de propiedades de configuración confidenciales.

Para obtener más información sobre IBM Cloud Schematics, consulte la documentación de IBM Cloud Schematics.

Para obtener más información sobre los datos confidenciales en estado Terraform, consulte Datos confidenciales en estado.

Para obtener más información sobre cómo establecer variables de entrada en Terraform, consulte Asignación de valores a variables de módulo raíz.

Supresión de datos de Continuous Delivery

Cuando suprime una instancia de servicio de Continuous Delivery, las cadenas de herramientas, las integraciones, las herramientas y los datos (incluidos datos personales) relacionados no se suprimen. Para obtener más información sobre cómo gestionar y suprimir datos almacenados con cadenas de herramientas, integraciones de herramientas y herramientas, consulte Modificación, exploración y supresión de datos personales.