Ao usar os Google Cloud componentes do 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 Google Cloud componentes do 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 criptografa automaticamente os dados em repouso usando 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: o ID do Google Cloud projeto.
- 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 da 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 Google Cloud componentes do pipeline define um conjunto de tipos de artefato de metadados de ML que servem como entrada e saída de componentes. Alguns Google Cloud componentes de pipeline 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 conferir 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])