Usar componentes de pipeline do Google Cloud

Ao usar os Google Cloud componentes do Google Cloud Pipeline (GCPC), é possível usar os seguintes recursos da plataforma de agentes do Gemini Enterprise 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 os pipelines da Gemini Enterprise Agent Platform.

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 dos pipelines da plataforma de agentes do Gemini Enterprise. Quando você usa o VPC Service Controls para criar um perímetro de serviço, os recursos e os dados que são criados pelos pipelines da plataforma de agentes do Gemini Enterprise e os Google Cloud componentes do 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 a plataforma de agentes do Gemini Enterprise.

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 plataforma de agentes do Gemini Enterprise.
  • NETWORK: a rede VPC, por exemplo, "projects/12345/global/networks/myVPC".

Saiba mais sobre o peering de rede VPC na Gemini Enterprise Agent Platform.

Usar chaves de criptografia gerenciadas pelo cliente (CMEK)

Por padrão, Google Cloud automaticamente criptografa 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 na plataforma de agentes do Gemini Enterprise e 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 à plataforma de agentes do Gemini Enterprise, 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 do.
  • 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: Google Cloud componentes que não são componentes da Gemini Enterprise Agent Platform 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 Google Cloud SDK define um conjunto de tipos de artefato de metadados de ML que servem como entrada e saída de componentes. Alguns Google Cloud componentes do 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 ModelUploadOp componente gera um artefato google.VertexModel que pode ser consumido por um ModelDeployOp componente. Use o seguinte código em um arquivo YAML de componente para recuperar um recurso Model da Gemini Enterprise Agent Platform das entradas (referência):

"model": "',"{{$.inputs.artifacts['model'].metadata['resourceName']}}", '"'

Para conferir o esquema completo dos metadados do artefato, consulte o artifact_types.py arquivo 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 Agent Platform 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])