Cuando usas componentes de canalización de Google Cloud (GCPC), puedes usar las siguientes funciones de Vertex AI y Google Cloud para proteger tus componentes y artefactos.
Especifica una cuenta de servicio para un componente
Cuando usas un componente, puedes especificar una cuenta de servicio de manera opcional.
Tu componente se inicia y actúa con los permisos de esta cuenta de servicio.
Por ejemplo, puedes usar el siguiente código para especificar la cuenta de servicio de un componente ModelDeploy:
model_deploy_op = ModelDeployOp(model=training_job_run_op.outputs["model"],
endpoint=endpoint_op.outputs["endpoint"],
automatic_resources_min_replica_count=1,
automatic_resources_max_replica_count=1,
service_account="SERVICE_ACCOUNT_ID@PROJECT_ID.iam.gserviceaccount.com")
Reemplaza lo siguiente:
- SERVICE_ACCOUNT_ID: El ID para la cuenta de servicio.
- PROJECT_ID: El ID del proyecto.
Obtén más información sobre cómo usar una cuenta de servicio personalizada y configurar una cuenta de servicio para usar con Vertex AI Pipelines.
Usa los Controles del servicio de VPC para evitar el robo de datos
Los Controles del servicio de VPC pueden ayudarte a mitigar el riesgo de robo de datos de Vertex AI Pipelines. Cuando usas los Controles del servicio de VPC para crear un perímetro de servicio, los recursos y los datos que crea Vertex AI Pipelines y los componentes de canalización de Google Cloud se protegen de forma automática. Por ejemplo, cuando usas los Controles del servicio de VPC para proteger tu canalización, los siguientes artefactos no pueden salir de tu perímetro de servicio:
- Datos de entrenamiento para un modelo de AutoML
- Modelos que creaste
- Resultados de una solicitud de predicción por lotes
Obtén más información sobre los Controles de servicio de VPC con Vertex AI.
Configura el intercambio de tráfico entre redes de VPC
Puedes proporcionar parámetros adicionales para configurar componentes de canalización de Google Cloud a fin de que intercambien el tráfico con una nube privada virtual. Por ejemplo, puedes usar el siguiente código a fin de especificar una red de VPC para un componente EndpointCreate:
endpoint_create_op = EndpointCreateOp(
project="PROJECT_ID",
location="REGION",
display_name="endpoint-display-name",
network="NETWORK")
Reemplaza lo siguiente:
- PROJECT_ID: El ID del proyecto.
- REGION: la región en la que usas Vertex AI.
- NETWORK: la red de VPC, por ejemplo,
"projects/12345/global/networks/myVPC".
Obtén más información sobre el intercambio de tráfico entre redes de VPC en Vertex AI.
Usar claves de encriptación administradas por el cliente (CMEK)
De forma predeterminada, Google Cloud encripta los datos cuando están en reposo de manera automática mediante claves de encriptación administradas por Google. Si tienes requisitos normativos o de cumplimiento específicos relacionados con las claves que protegen los datos, puedes usar claves de encriptación administradas por el cliente (CMEK) para los recursos. Antes de comenzar a usar las claves de encriptación administradas por el cliente, obtén más información sobre los beneficios de CMEK en Vertex AI y los recursos compatibles con CMEK actuales.
Configura tu componente con CMEK
Después de crear un llavero de claves y una clave en Cloud Key Management Service y otorgar permisos de encriptador y desencriptador de Vertex AI para tu clave, puedes crear un nuevo componente compatible con CMEK si especificas tu clave como uno de los parámetros para crear. Por ejemplo, puedes usar el siguiente código a fin de especificar una clave para un componente ModelBatchPredict:
model_batch_predict_op = ModelBatchPredictOp(project="PROJECT_ID",
model=model_upload_op.outputs["model"],
encryption_spec_key_name="projects/PROJECT_ID/locations/LOCATION_ID/keyRings/KEY_RING_NAME/cryptoKeys/KEY_NAME")
Reemplaza lo siguiente:
- PROJECT_ID es el ID del proyecto de Google Cloud.
- LOCATION_ID: es un identificador de ubicación o región válido, por ejemplo,
us-central1. - KEY_RING_NAME: es el nombre del llavero de claves de las CMEK. Para obtener más información sobre los llaveros de claves, consulta Recursos de Cloud KMS.
- KEY_NAME: es el nombre de la clave CMEK.
Nota: Es posible que los componentes de Google Cloud que no son componentes de Vertex AI requieran permisos adicionales. Por ejemplo, un componente de BigQuery puede requerir un permiso de encriptación y desencriptación. Además, la ubicación de la clave CMEK debe ser la misma que la ubicación del componente. Por ejemplo, si un componente de BigQuery carga datos de un conjunto de datos basado en la ubicación multirregional de EE.UU., la clave CMEK también debe estar basada en la ubicación multirregional de EE.UU.
Consume o produce artefactos en tu componente
El SDK de los componentes de canalización de Google Cloud define un conjunto de tipos de artefactos de metadatos de AA que funcionan como entrada y salida de componentes. Algunos componentes de canalización de Google Cloud consumen estos artefactos como entrada o los producen como salida.
En esta página, se muestra cómo consumir y producir estos artefactos.
Consume un artefacto de AA
Consume un artefacto en el componente YAML
Los metadatos del artefacto pueden servir como entrada a un componente. A fin de preparar un artefacto para que se consuma como entrada, debes extraerlo y colocarlo en un archivo YAML de componente.
Por ejemplo, el componente ModelUploadOp genera un artefacto google.VertexModel que un componente ModelDeployOp puede consumir. Usa el siguiente código en un archivo YAML de componente para recuperar el recurso Model de Vertex AI de las entradas (referencia):
"model": "',"{{$.inputs.artifacts['model'].metadata['resourceName']}}", '"'
Para ver el esquema completo de los metadatos del artefacto, consulta el archivo artifact_types.py en el repositorio de GitHub de Kubeflow.
Consume un artefacto en un componente liviano de Python
from kfp.dsl import Artifact, Input
@dsl.component
def classification_model_eval_metrics(
project: str,
location: str, # "us-central1",
model: Input[Artifact],
) :
# Consumes the `resourceName` metadata
model_resource_path = model.metadata["resourceName"]
Para ver un ejemplo de cómo consumir los tipos de artefactos de Vertex ML Metadata, consulta Entrena un modelo de clasificación con datos tabulares y AutoML de Vertex AI.
Crea un artefacto de AA
En los siguientes ejemplos de código, se muestra cómo crear un artefacto de Vertex ML Metadata que un componente de GCPC puede aceptar como entrada.
Usa un nodo importador
En el siguiente ejemplo, se crea un nodo importador que registra una entrada de artefacto nueva en Vertex ML Metadata. El nodo importador toma el URI y los metadatos del artefacto como primitivos y los empaqueta en un artefacto.
from google_cloud_pipeline_components import v1
from google_cloud_pipeline_components.types import artifact_types
from kfp.components import importer_node
from kfp import dsl
@dsl.pipeline(name=_PIPELINE_NAME)
def pipeline():
# Using importer and UnmanagedContainerModel artifact for model upload
# component.
importer_spec = importer_node.importer(
artifact_uri='gs://managed-pipeline-gcpc-e2e-test/automl-tabular/model',
artifact_class=artifact_types.UnmanagedContainerModel,
metadata={
'containerSpec': {
'imageUri':
'us-docker.pkg.dev/vertex-ai/automl-tabular/prediction-server:prod'
}
})
# Consuming the UnmanagedContainerModel artifact for the previous step
model_upload_with_artifact_op = v1.model.ModelUploadOp(
project=_GCP_PROJECT_ID,
location=_GCP_REGION,
display_name=_MODEL_DISPLAY_NAME,
unmanaged_container_model=importer_spec.outputs['artifact'])
Usa componentes basados en funciones de Python
En el siguiente ejemplo, se muestra cómo generar un artefacto de Vertex ML Metadata directamente desde un componente de Python.
from google_cloud_pipeline_components import v1
from kfp.components import importer_node
from kfp import dsl
@dsl.component(
base_image='python:3.9',
packages_to_install=['google-cloud-aiplatform'],
)
# Note currently KFP SDK doesn't support outputting artifacts in `google` namespace.
# Use the base type dsl.Artifact instead.
def return_unmanaged_model(model: dsl.Output[dsl.Artifact]):
model.metadata['containerSpec'] = {
'imageUri':
'us-docker.pkg.dev/vertex-ai/automl-tabular/prediction-server:prod'
}
model.uri = f'gs://automl-tabular-pipeline/automl-tabular/model'
@dsl.pipeline(name=_PIPELINE_NAME)
def pipeline():
unmanaged_model_op = return_unmanaged_model()
# Consuming the UnmanagedContainerModel artifact for the previous step
model_upload_with_artifact_op = v1.model.ModelUploadOp(
project=_GCP_PROJECT_ID,
location=_GCP_REGION,
display_name=_MODEL_DISPLAY_NAME,
unmanaged_container_model=unmanaged_model_op.outputs['model'])
Usa tu propio componente basado en contenedores
En el siguiente ejemplo, se muestra cómo generar un artefacto VertexBatchPredictionJob como resultado de un componente basado en contenedores mediante la clase de utilidad artifact_types.py.
bp_job_artifact = VertexBatchPredictionJob(
'batchpredictionjob', vertex_uri_prefix + get_job_response.name,
get_job_response.name, get_job_response.output_info.bigquery_output_table,
get_job_response.output_info.bigquery_output_dataset,
get_job_response.output_info.gcs_output_directory)
output_artifacts = executor_input_json.get('outputs', {}).get('artifacts', {})
executor_output['artifacts'] = bp_job_artifact.to_executor_output_artifact(output_artifacts[bp_job_artifact.name])