Cuando usas Google Cloud componentes de flujo de procesamiento (GCPC), puedes usar las siguientes funciones de Vertex AI y Google Cloud para proteger tus componentes y artefactos.
Especificar una cuenta de servicio para un componente
Cuando usas un componente, puedes especificar una cuenta de servicio de forma 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")
Haz los cambios siguientes:
- SERVICE_ACCOUNT_ID: ID de la cuenta de servicio.
- PROJECT_ID: el ID del proyecto.
Consulta más información sobre cómo usar una cuenta de servicio personalizada y cómo configurar una cuenta de servicio para usarla con Vertex AI Pipelines.
Usar Controles de Servicio de VPC para evitar la filtración de datos
Controles de Servicio de VPC puede ayudarte a mitigar el riesgo de filtración externa de datos de Vertex AI Pipelines. Cuando usas Controles de servicio de VPC para crear un perímetro de servicio, los recursos y los datos que crean Vertex AI Pipelines y los Google Cloud componentes de flujo de trabajo se protegen automáticamente. Por ejemplo, cuando usas Controles de Servicio de VPC para proteger tu pipeline, los siguientes artefactos no pueden salir de tu perímetro de servicio:
- Datos de entrenamiento de un modelo de AutoML
- Modelos que has creado
- Resultados de una solicitud de predicción por lotes
Consulta más información sobre Controles de Servicio de VPC con Vertex AI.
Configurar emparejamiento entre redes de VPC
Puedes configurar Google Cloud componentes de canalización para que se comuniquen con una nube privada virtual proporcionando parámetros adicionales. Por ejemplo, puedes usar el siguiente código para 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")
Haz los cambios siguientes:
- 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".
Consulta más información sobre el emparejamiento entre redes de VPC en Vertex AI.
Usar claves de encriptado gestionadas por el cliente (CMEK)
De forma predeterminada, Google Cloud cifra automáticamente los datos en reposo con claves de cifrado gestionadas por Google. Si tienes requisitos normativos o de cumplimiento específicos relacionados con las claves que protegen tus datos, puedes usar claves de cifrado gestionadas por el cliente (CMEK) para tus recursos. Antes de empezar a usar claves de encriptado gestionadas por el cliente, consulta las ventajas de CMEK en Vertex AI y los recursos compatibles con CMEK.
Configurar un componente con CMEK
Después de crear un conjunto de claves y una clave en Cloud Key Management Service y de conceder permisos de cifrado y descifrado de Vertex AI a tu clave, puedes crear un componente compatible con CMEK especificando tu clave como uno de los parámetros de creación. Por ejemplo, puedes usar el siguiente código para 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")
Haz los cambios siguientes:
- PROJECT_ID: tu ID de proyecto Google Cloud .
- LOCATION_ID: un identificador de ubicación o región válido, como
us-central1. - KEY_RING_NAME: el nombre del conjunto de claves de tu CMEK. Para obtener más información sobre los conjuntos de claves, consulta Recursos de Cloud KMS.
- KEY_NAME: nombre de la clave CMEK.
Nota: Es posible que los componentes Google Cloud que no sean de Vertex AI requieran permisos adicionales. Por ejemplo, un componente de BigQuery puede requerir permisos de cifrado y descifrado. Además, la ubicación de la clave CMEK debe ser la misma que la del componente. Por ejemplo, si un componente de BigQuery carga datos de un conjunto de datos ubicado en la multirregión de EE. UU., la clave CMEK también debe estar ubicada en la multirregión de EE. UU.
Consumir o generar artefactos en tu componente
El SDK de Google Cloud define un conjunto de tipos de artefactos de metadatos de aprendizaje automático que sirven como entrada y salida de componentes. Algunos Google Cloud componentes de la canalización consumen estos artefactos como entrada o los producen como salida.
En esta página se muestra cómo consumir y generar estos artefactos.
Consumir un artefacto de aprendizaje automático
Consumir un artefacto en un archivo YAML de componente
Los metadatos del artefacto pueden servir como entrada para un componente. Para preparar un artefacto que se va a usar como entrada, debes extraerlo y colocarlo en un archivo YAML de componente.
Por ejemplo, el componente ModelUploadOp genera un artefacto google.VertexModel que puede usar un componente ModelDeployOp. Usa el siguiente código en un archivo YAML de componente para recuperar un 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.
Consumir un artefacto en un componente de Python ligero
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 usar los tipos de artefactos de Vertex ML Metadata, consulta Entrenar un modelo de clasificación con datos tabulares y Vertex AI AutoML.
Crear un artefacto de AA
En los siguientes ejemplos de código se muestra cómo crear un artefacto de metadatos de Vertex ML que un componente de GCPC puede aceptar como entrada.
Usar un nodo de importación
En el siguiente ejemplo se crea un nodo Importer que registra una nueva entrada de artefacto en los metadatos de Vertex ML. El nodo de importación toma el URI y los metadatos del artefacto como primitivas 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'])
Usar componentes basados en funciones de Python
En el siguiente ejemplo se muestra cómo generar un artefacto de metadatos de Vertex ML 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'])
Usar tu propio componente basado en contenedores
En el siguiente ejemplo se muestra cómo generar un artefacto VertexBatchPredictionJob como salida 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])