Ao usar os componentes do Google Cloud Pipeline (GCPC), é possível usar os seguintes recursos do Vertex AI e Google Cloud para proteger seus componentes e artefatos.
Especificar uma conta de serviço para um componente
Quando você usa um componente, há a opção de especificar uma conta de serviço.
O componente é iniciado e age com as permissões dessa conta de serviço.
Por exemplo, é possível 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:
- 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 uso com o Vertex AI Pipelines.
Usar o VPC Service Controls para evitar a exfiltração de dados
O VPC Service Controls pode ajudar você a reduzir o risco de exfiltração de dados do Vertex AI Pipelines. Quando você usa o VPC Service Controls para criar um perímetro de serviço, os recursos e os dados criados pelo Vertex AI Pipelines e os componentes do Google Cloud Pipeline são automaticamente protegidos. Por exemplo, quando você usa o VPC Service Controls para proteger o pipeline, os artefatos a seguir não podem deixar o perímetro de serviço:
- Dados de treinamento para um modelo do AutoML
- Modelos que você criou
- Resultados de uma solicitação de previsão em lote
Saiba mais sobre o VPC Service Controls com o Vertex AI.
Configurar o peering de rede VPC
É possível configurar os componentes do Google Cloud Pipeline para fazer peering com uma nuvem privada virtual fornecendo parâmetros extras. Por exemplo, é possível usar o seguinte código para especificar uma rede VPC para um componente EndpointCreate:
endpoint_create_op = EndpointCreateOp(
project="PROJECT_ID",
location="REGION",
display_name="endpoint-display-name",
network="NETWORK")
Substitua:
- PROJECT_ID: o ID do projeto
- REGION: a região em que você está usando a Vertex AI.
- NETWORK: a rede VPC, por exemplo,
"projects/12345/global/networks/myVPC"
Saiba mais sobre o peering de rede VPC no Vertex AI.
Usar chaves de criptografia gerenciadas pelo cliente (CMEK)
Por padrão, o Google Cloud automaticamente criptografa os dados quando em repouso por meio de chaves de criptografia gerenciadas pelo Google. Caso você precise atender a requisitos específicos de compliance e conformidade relacionados às chaves que protegem seus dados, use as chaves de criptografia gerenciadas pelo cliente (CMEKs, na sigla em inglês) para os recursos. Antes de começar a usar chaves de criptografia gerenciadas pelo cliente, saiba mais sobre os benefícios das CMEKs no Vertex AI e dos recursos atuais compatíveis com CMEK.
Como configurar um componente com CMEK
Depois de criar um keyring e uma chave no
Cloud Key Management Service
e conceder permissões de criptografia e descriptografia à Vertex AI,
crie um novo suporte a CMEK especificando sua chave como um dos parâmetros de criação. Por exemplo, é possível usar o seguinte código 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:
- PROJECT_ID pelo ID do projeto no Google Cloud.
- LOCATION_ID: um identificador válido de região ou local, por exemplo,
us-central1. - KEY_RING_NAME: o nome do keyring para CMEK. Para mais informações sobre keyrings, consulte Recursos do Cloud KMS.
- KEY_NAME: o nome da chave CMEK.
Observação: componentes do Google Cloud que não são da Vertex AI podem exigir permissões extras. Por exemplo, um componente do BigQuery pode exigir permissão de criptografia e descriptografia. Além disso, o local da chave CMEK precisa ser o mesmo do componente. Por exemplo, se um componente do BigQuery carregar dados de um conjunto de dados baseado no local multirregional dos EUA, a chave CMEK também precisará estar no local multirregional dos EUA.
Consumir ou produzir artefatos no componente
O SDK dos componentes do Google Cloud Pipeline define um conjunto de tipos de artefato de metadados de ML que servem como entrada e saída de componentes. Alguns componentes de pipeline do Google Cloud consomem esses artefatos como entrada ou os produzem como saída.
Nesta página, você verá como consumir e produzir esses artefatos.
Consumir um artefato de ML
Consumir um artefato no componente YAML
Os metadados do artefato podem servir como entrada para um componente. Para preparar um artefato a ser consumido como entrada, é preciso extraí-lo e colocá-lo em um arquivo YAML do componente.
Por exemplo, o componente ModelUploadOp gera um artefato google.VertexModel que pode ser consumido por um componente ModelDeployOp. Use o seguinte código em um arquivo YAML de componente para recuperar um recurso Model do Vertex AI das entradas (referência):
"model": "',"{{$.inputs.artifacts['model'].metadata['resourceName']}}", '"'
Para ver o esquema completo dos metadados do artefato, consulte o arquivo artifact_types.py no repositório do Kubeflow no GitHub.
Consumir um artefato em um componente leve do 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 um exemplo de como consumir os tipos de artefatos do Vertex ML Metadata, consulte Treinar um modelo de classificação usando dados tabulares e o Vertex AI AutoML.
Criar um artefato de ML
Os exemplos de código a seguir mostram como criar um artefato do Vertex ML Metadata que um componente do GCPC possa aceitar como entrada.
Usar um nó de importação
O exemplo a seguir cria um nó do importador que registra uma nova entrada de artefato no Vertex ML Metadata. O nó do importador usa o URI e os metadados do artefato como primitivos e os empacota em um artefato.
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 baseados em função do Python
O exemplo a seguir mostra como gerar um artefato de Vertex ML Metadata diretamente de um componente do 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 seu próprio componente baseado em contêineres
O exemplo a seguir mostra como gerar um artefato VertexBatchPredictionJob como saída de um componente baseado em contêiner usando a classe de utilitário
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])