Quando usa Google Cloud componentes de pipeline (GCPC), pode usar as seguintes funcionalidades do Vertex AI e Google Cloud para proteger os seus componentes e artefactos.
Especifique uma conta de serviço para um componente
Quando usa um componente, pode especificar opcionalmente uma conta de serviço.
O seu componente é iniciado e age com as autorizações desta conta de serviço.
Por exemplo, pode usar o seguinte código para especificar a conta de serviço de um 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")
Substitua o seguinte:
- SERVICE_ACCOUNT_ID: o ID da conta de serviço.
- PROJECT_ID: o ID do projeto.
Saiba mais sobre como usar uma conta de serviço personalizada e configurar uma conta de serviço para utilização com o Vertex AI Pipelines.
Use os VPC Service Controls para impedir a exfiltração de dados
Os VPC Service Controls podem ajudar a mitigar o risco de exfiltração de dados dos Vertex AI Pipelines. Quando usa os VPC Service Controls para criar um perímetro de serviço, os recursos e os dados criados pelos Vertex AI Pipelines e pelos Google Cloud componentes de pipeline são protegidos automaticamente. Por exemplo, quando usa os VPC Service Controls para proteger o seu pipeline, os seguintes artefactos não podem sair do seu perímetro de serviço:
- Dados de preparação para um modelo do AutoML
- Modelos que criou
- Resultados de um pedido de previsão em lote
Saiba mais sobre os VPC Service Controls com a Vertex AI.
Configure o intercâmbio da rede de VPC
Pode configurar Google Cloud componentes do pipeline para estabelecer uma relação de intercâmbio com uma nuvem privada virtual fornecendo parâmetros adicionais. Por exemplo, pode usar o seguinte código para especificar uma rede de VPC para um componente EndpointCreate:
endpoint_create_op = EndpointCreateOp(
project="PROJECT_ID",
location="REGION",
display_name="endpoint-display-name",
network="NETWORK")
Substitua o seguinte:
- PROJECT_ID: o ID do projeto.
- REGION: a região onde está a usar o Vertex AI.
- NETWORK: A rede VPC, por exemplo,
"projects/12345/global/networks/myVPC".
Saiba mais sobre o intercâmbio da rede da VPC na Vertex AI.
Use chaves de encriptação geridas pelo cliente (CMEK)
Por predefinição, Google Cloud encripta automaticamente os dados em repouso com chaves de encriptação geridas pela Google. Se tiver requisitos regulamentares ou de conformidade específicos relacionados com as chaves que protegem os seus dados, pode usar chaves de encriptação geridas pelo cliente (CMEK) para os seus recursos. Antes de começar a usar as chaves de encriptação geridas pelo cliente, saiba mais sobre as vantagens das CMEK no Vertex AI e os recursos atualmente suportados pelas CMEK.
Configurar o componente com CMEK
Depois de criar um conjunto de chaves e uma chave no
Cloud Key Management Service,
e conceder permissões de encriptação e desencriptação do Vertex AI para a sua chave,
pode criar um novo componente suportado pela CMEK especificando a sua chave como um dos
parâmetros de criação. Por exemplo, pode usar o código seguinte para especificar
uma chave para um 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")
Substitua o seguinte:
- PROJECT_ID: o ID do seu Google Cloud projeto.
- LOCATION_ID: um identificador de localização ou região válido, por exemplo,
us-central1. - KEY_RING_NAME: o nome do conjunto de chaves para a sua CMEK. Para mais informações acerca dos conjuntos de chaves, consulte o artigo Recursos do Cloud KMS.
- KEY_NAME: o nome da chave CMEK.
Nota: Google Cloud os componentes que não são componentes da Vertex AI podem exigir autorizações adicionais. Por exemplo, um componente do BigQuery pode exigir autorização de encriptação e desencriptação. Além disso, a localização da chave CMEK tem de ser a mesma que a localização do componente. Por exemplo, se um componente do BigQuery carregar dados de um conjunto de dados com base na localização multirregional dos EUA, a chave CMEK também tem de se basear na localização multirregional dos EUA.
Consuma ou produza artefactos no seu componente
O Google Cloud SDK define um conjunto de tipos de artefactos de metadados de ML que servem como entrada e saída de componentes. Alguns Google Cloud componentes do pipeline consomem estes artefactos como entrada ou produzem-nos como saída.
Esta página mostra como consumir e produzir estes artefactos.
Consuma um artefacto de AA
Consuma um artefacto no YAML do componente
Os metadados do artefacto podem servir como entrada para um componente. Para preparar um artefacto para ser consumido como entrada, tem de o extrair e colocá-lo num ficheiro YAML do componente.
Por exemplo, o componente ModelUploadOp gera um artefacto google.VertexModel que pode ser usado por um componente ModelDeployOp. Use o seguinte código num ficheiro YAML de componente para obter o recurso Model do Vertex AI a partir das entradas (referência):
"model": "',"{{$.inputs.artifacts['model'].metadata['resourceName']}}", '"'Para ver o esquema completo dos metadados do artefacto, consulte o ficheiro artifact_types.py
no repositório do Kubeflow no GitHub.
Consuma um artefacto num componente Python leve
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 um exemplo de como consumir os tipos de artefactos do Vertex ML Metadata, consulte o artigo Prepare um modelo de classificação com dados tabulares e o Vertex AI AutoML.
Crie um artefacto de ML
Os exemplos de código seguintes mostram como criar um artefacto Vertex ML Metadata que um componente do GCPC pode aceitar como entrada.
Use um nó de importação
O exemplo seguinte cria um nó Importer que regista uma nova entrada de artefacto no Vertex ML Metadata. O nó do importador recebe o URI e os metadados do artefacto como primitivos e agrupa-os num 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'])
Use componentes baseados em funções Python
O exemplo seguinte mostra como gerar um artefacto de metadados do Vertex ML diretamente a partir de um componente 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'])
Use o seu próprio componente baseado em contentor
O exemplo seguinte mostra como gerar um artefacto VertexBatchPredictionJob como resultado de um componente baseado em contentores através da classe de utilidade 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])