Esta página foi traduzida pela API Cloud Translation.

Interface do Private Service Connect Vertex AI Pipelines

1. Introdução

A interface do Private Service Connect é um recurso que permite que uma rede de nuvem privada virtual (VPC) do produtor inicie conexões com vários destinos em uma rede de consumidor. As redes de produtor e consumidor podem estar em diferentes projetos e organizações.

Uma conexão entre um anexo de rede e uma interface do Private Service Connect é semelhante à conexão entre um endpoint do Private Service Connect e um anexo de serviço, mas há duas diferenças importantes:

Um anexo de rede permite que uma rede produtora inicie conexões com uma rede consumidora (saída de serviço gerenciada), enquanto um endpoint permite que uma rede consumidora inicie conexões com uma rede produtora (entrada de serviço gerenciada).
Uma conexão de interface do Private Service Connect é transitiva. Isso significa que uma rede do produtor pode se comunicar com outras que estão conectadas à rede do consumidor.

O que você vai criar

O Vertex AI Pipelines, implantado em um projeto de locatário gerenciado pelo Google, vai aproveitar o anexo de rede PSC para criar uma instância multi-nic entre a rede produtora e a consumidora. Como o anexo de rede PSC é implantado com um multi-nic da rede do consumidor, os pipelines da Vertex AI podem acessar as rotas disponíveis na rede do consumidor.

Neste tutorial, você vai criar uma arquitetura de interface abrangente do Private Service Connect (PSC) para pipelines da Vertex AI que utilize regras do Cloud Firewall para permitir ou negar a conectividade do produtor às instâncias de teste do consumidor, conforme ilustrado na Figura 1.

Figura 1.

Você vai criar um único psc-network-attachment na VPC do consumidor, resultando nos seguintes casos de uso:

Crie uma regra de firewall de entrada na VPC do consumidor para permitir que a sub-rede do pipeline do Vertex AI (192.168.10.0/28) acesse o test-svc-1. Confirme o PING gerado pelo job do pipeline para test-svc-1 usando o TCPDUMP
Crie uma regra de firewall de entrada na VPC do consumidor que negue a sub-rede do pipeline da Vertex AI (192.168.10.0/28) para test-svc-2. Confirme a falha do PING com base nos registros de firewall gerados pelo Log Explorer.

O que você vai aprender

Como criar um anexo de rede
Como o Vertex AI Pipelines pode usar um anexo de rede para criar uma interface PSC
Como estabelecer a comunicação do produtor com o consumidor
Como permitir o acesso do Vertex AI Pipelines à VM do consumidor, test-svc-1
Como negar o acesso dos pipelines da Verex AI à VM do consumidor, test-svc-2, usando o Cloud Firewall

O que é necessário

Projeto do Google Cloud
Permissões do IAM
Administrador de instâncias do Compute (roles/compute.instanceAdmin)
Administrador de rede do Compute (roles/compute.networkAdmin)
Administrador de segurança do Compute (roles/compute.securityAdmin)
Usuário de túnel protegido pelo IAP (roles/iap.tunnelResourceAccessor)
Administrador da geração de registros (roles/logging.admin)
Administrador de notebooks (roles/notebooks.admin)
Administrador do IAM do projeto (roles/resourcemanager.projectIamAdmin)
Administrador de cota (roles/servicemanagement.quotaAdmin)
Administrador da conta de serviço (roles/iam.serviceAccountAdmin)
Usuário da conta de serviço (roles/iam.serviceAccountUser)
Administrador da Vertex AI (roles/aiplatform.admin)

2. Antes de começar

Este tutorial usa $variables para ajudar na implementação da configuração do gcloud no Cloud Shell.

No Cloud Shell, faça o seguinte:

gcloud config list project
gcloud config set project [YOUR-PROJECT-NAME]
projectid=YOUR-PROJECT-NAME
echo $projectid

Atualizar o projeto para oferecer suporte ao tutorial

No Cloud Shell, faça o seguinte:

gcloud services enable notebooks.googleapis.com
gcloud services enable aiplatform.googleapis.com
gcloud services enable compute.googleapis.com
gcloud services enable cloudresourcemanager.googleapis.com

3. Configuração do consumidor

Criar a VPC do consumidor

No Cloud Shell, faça o seguinte:

gcloud compute networks create consumer-vpc --project=$projectid --subnet-mode=custom

Criar as sub-redes do consumidor

No Cloud Shell, faça o seguinte:

gcloud compute networks subnets create test-subnet-1 --project=$projectid --range=192.168.20.0/28 --network=consumer-vpc --region=us-central1

No Cloud Shell, faça o seguinte:

gcloud compute networks subnets create test-subnet-2 --project=$projectid --range=192.168.30.0/28 --network=consumer-vpc --region=us-central1

No Cloud Shell, faça o seguinte:

gcloud compute networks subnets create workbench-subnet --project=$projectid --range=192.168.40.0/28 --network=consumer-vpc --region=us-central1 --enable-private-ip-google-access

Configuração do Cloud Router e NAT

A conversão de endereços de rede (NAT, na sigla em inglês) do Cloud é usada no tutorial para downloads de pacotes de software de notebooks, já que a instância de notebook não tem um endereço IP externo. O Cloud NAT oferece recursos de NAT de saída, o que significa que os hosts da Internet não podem iniciar a comunicação com um notebook gerenciado pelo usuário, tornando-o mais seguro.

No Cloud Shell, crie o Cloud Router regional.

gcloud compute routers create cloud-router-us-central1 --network consumer-vpc --region us-central1

No Cloud Shell, crie o gateway regional do Cloud NAT.

gcloud compute routers nats create cloud-nat-us-central1 --router=cloud-router-us-central1 --auto-allocate-nat-external-ips --nat-all-subnet-ip-ranges --region us-central1

Criar a sub-rede de anexo de rede do Private Service Connect

No Cloud Shell, crie a sub-rede de anexo de rede usada pelo Vertex AI Pipelines.

gcloud compute networks subnets create intf-subnet --project=$projectid --range=192.168.10.0/28 --network=consumer-vpc --region=us-central1

4. Ativar o Identity-Aware Proxy (IAP)

Para permitir que o IAP se conecte às suas instâncias de VM, crie uma regra de firewall que:

Aplica-se a todas as instâncias da VM que você quer que sejam acessíveis usando o IAP.
Permite o tráfego de entrada do intervalo de IP 35.235.240.0/20. Esse intervalo contém todos os endereços IP que o IAP usa para o encaminhamento de TCP.

No Cloud Shell, crie a regra de firewall do IAP.

gcloud compute firewall-rules create ssh-iap-consumer \
    --network consumer-vpc \
    --allow tcp:22 \
    --source-ranges=35.235.240.0/20

5. Criar instâncias de VM do consumidor

No Cloud Shell, crie a instância de VM do consumidor, test-svc-1.

gcloud compute instances create test-svc-1 \
    --project=$projectid \
    --machine-type=e2-micro \
    --image-family debian-11 \
    --no-address \
    --image-project debian-cloud \
    --zone us-central1-a \
    --subnet=test-subnet-1 \
    --shielded-secure-boot

No Cloud Shell, crie a instância de VM do consumidor, test-svc-2.

gcloud compute instances create test-svc-2 \
    --project=$projectid \
    --machine-type=e2-micro \
    --image-family debian-11 \
    --no-address \
    --image-project debian-cloud \
    --zone us-central1-a \
    --subnet=test-subnet-2 \
    --shielded-secure-boot

Consiga e armazene os endereços IP das instâncias:

No Cloud Shell, execute uma descrição das instâncias de VM de teste.

gcloud compute instances describe test-svc-1 --zone=us-central1-a | grep  networkIP:

gcloud compute instances describe test-svc-2 --zone=us-central1-a | grep  networkIP:

Exemplo:

user@cloudshell(psc-vertex)$ gcloud compute instances describe test-svc-1 --zone=us-central1-a | grep  networkIP:

gcloud compute instances describe test-svc-2 --zone=us-central1-a | grep  networkIP:
  networkIP: 192.168.20.2
  networkIP: 192.168.30.2

6. Anexo de rede do Private Service Connect

Os anexos de rede são recursos regionais que representam o lado do consumidor de uma interface do Private Service Connect. Você associa uma única sub-rede a um anexo de rede, e o produtor (pipelines da Vertex AI) atribui IPs à interface do Private Service Connect.

Criar o anexo de rede

No Cloud Shell, crie o anexo de rede.

gcloud compute network-attachments create psc-network-attachment \
    --region=us-central1 \
    --connection-preference=ACCEPT_MANUAL \
    --subnets=intf-subnet

Listar os anexos de rede

No Cloud Shell, liste o anexo de rede.

gcloud compute network-attachments list

Descrever os anexos de rede

No Cloud Shell, descreva o anexo de rede.

gcloud compute network-attachments describe psc-network-attachment --region=us-central1

Anote o URI psc-network-attachment que será usado pelo produtor ao criar a interface do Private Service Connect.

No exemplo abaixo, o URI do anexo de rede psc é o seguinte:

projects/psc-vertex/regions/us-central1/networkAttachments/psc-network-attachment

user@cloudshell$ gcloud compute network-attachments describe psc-network-attachment --region=us-central1
connectionPreference: ACCEPT_MANUAL
creationTimestamp: '2025-01-21T12:25:25.385-08:00'
fingerprint: m9bHc9qnosY=
id: '56224423547354202'
kind: compute#networkAttachment
name: psc-network-attachment
network: https://www.googleapis.com/compute/v1/projects/psc-vertex/global/networks/consumer-vpc
region: https://www.googleapis.com/compute/v1/projects/psc-vertex/regions/us-central1
selfLink: https://www.googleapis.com/compute/v1/projects/psc-vertex/regions/us-central1/networkAttachments/psc-network-attachment
subnetworks:
- https://www.googleapis.com/compute/v1/projects/psc-vertex/regions/us-central1/subnetworks/intf-subnet

7. Configuração do Vertex AI Workbench

A seção a seguir orienta você na criação de um Jupyter Notebook. Este notebook será usado para implantar um job do Pipelines que envia um PING dos Pipelines da Vertex AI para as instâncias de teste. O caminho de dados entre o Vertex AI Pipelines e a rede de consumo que contém as instâncias usa uma interface de rede do Private Service Connect.

Criar uma conta de serviço gerenciada pelo usuário

Na próxima seção, você vai criar uma conta de serviço que será associada à instância do Vertex AI Workbench usada no tutorial.

No tutorial, as seguintes funções serão aplicadas à conta de serviço:

No Cloud Shell, crie a conta de serviço.

gcloud iam service-accounts create notebook-sa \
    --display-name="notebook-sa"

No Cloud Shell, atualize a conta de serviço com o papel de administrador do Storage.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/storage.admin"

No Cloud Shell, atualize a conta de serviço com a função de usuário da Vertex AI.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/aiplatform.user"

No Cloud Shell, atualize a conta de serviço com o papel de administrador do Artifact Registry.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/artifactregistry.admin"

No Cloud Shell, permita que a conta de serviço do notebook use a conta de serviço padrão do Compute Engine para instanciar o job do pipeline.

gcloud iam service-accounts add-iam-policy-binding \
    $(gcloud projects describe $(gcloud config get-value project) --format='value(projectNumber)')-compute@developer.gserviceaccount.com \
    --member="serviceAccount:notebook-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/iam.serviceAccountUser"

Criar uma instância do Vertex AI Workbench

Na seção a seguir, crie uma instância do Vertex AI Workbench que incorpore a conta de serviço criada anteriormente, notebook-sa.

No Cloud Shell, crie a instância de cliente particular.

gcloud workbench instances create workbench-tutorial --vm-image-project=deeplearning-platform-release --vm-image-family=common-cpu-notebooks --machine-type=n1-standard-4 --location=us-central1-a --subnet-region=us-central1 --subnet=workbench-subnet --disable-public-ip --shielded-secure-boot=true --service-account-email=notebook-sa@$projectid.iam.gserviceaccount.com

8. Vertex AI Pipelines para conectividade test-svc-1

Abra uma nova guia do Cloud Shell e atualize as configurações do projeto.

No Cloud Shell, faça o seguinte:

gcloud config list project
gcloud config set project [YOUR-PROJECT-NAME]
projectid=YOUR-PROJECT-NAME
echo $projectid

Para permitir a conectividade dos pipelines do Vertex AI com o test-svc-1, crie uma regra de firewall de entrada que especifique a vinculação de rede PSC como a origem (192.168.10.0/28) e o endereço IP test-svc-1 como o destino.

No Cloud Shell, atualize o destino para corresponder ao endereço IP test-svc-1.

gcloud compute --project=$projectid firewall-rules create allow-icmp-vertex-pipelines-to-test-svc1-vm --direction=INGRESS --priority=1000 --network=consumer-vpc --action=ALLOW  --source-ranges=192.168.10.0/28 --destination-ranges=<your-test-svc-1-vm-ip> --rules=icmp

Exemplo:

gcloud compute --project=$projectid firewall-rules create allow-icmp-vertex-pipelines-to-test-svc1-vm --direction=INGRESS --priority=1000 --network=consumer-vpc --action=ALLOW  --source-ranges=192.168.10.0/28 --destination-ranges=192.168.20.2 --rules=icmp

Faça login na instância test-svc-1 usando o IAP no Cloud Shell.

gcloud compute ssh test-svc-1 --project=$projectid --zone=us-central1-a --tunnel-through-iap

No SO, execute o tcpdump para capturar qualquer tráfego icmp. Essa sessão do SO será usada para validar a comunicação entre o pipeline da Vertex AI e a VM.

sudo tcpdump -i any icmp -nn

9. Atualização do agente de serviço da Vertex AI

O Vertex AI Pipelines atua em seu nome para realizar operações, como receber um endereço IP da sub-rede de anexo de rede do PSC usada para criar a interface do PSC. Para isso, o Vertex AI Pipelines usa um agente de serviço (listado abaixo) que exige a permissão Administrador de rede.

service-$projectnumber@gcp-sa-aiplatform.iam.gserviceaccount.com

No Cloud Shell, confira o número do projeto.

gcloud projects describe $projectid | grep projectNumber

Exemplo:

gcloud projects describe $projectid | grep projectNumber:
projectNumber: '795057945528'

No Cloud Shell, atualize a conta de agente de serviço com o papel compute.networkAdmin.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:service-<your-projectnumber>@gcp-sa-aiplatform.iam.gserviceaccount.com" --role="roles/compute.networkAdmin"

Exemplo:

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:service-795057945528@gcp-sa-aiplatform.iam.gserviceaccount.com" --role="roles/compute.networkAdmin"

10. Atualização da conta de serviço padrão

Ative a API Compute Engine e conceda à sua conta de serviço padrão acesso à Vertex AI. Pode levar algum tempo para a mudança no acesso ser propagada.

No Cloud Shell, atualize a conta de serviço padrão com o papel aiplatform.user

gcloud projects add-iam-policy-binding $projectid \
  --member="serviceAccount:<your-projectnumber>-compute@developer.gserviceaccount.com" \
    --role="roles/aiplatform.user"

Exemplo:

gcloud projects add-iam-policy-binding $projectid \
  --member="serviceAccount:795057945528-compute@developer.gserviceaccount.com" \
    --role="roles/aiplatform.user"

11. Implantar o job do Vertex AI Pipelines

Na próxima seção, você vai criar um notebook para executar um PING bem-sucedido na instância de consumidor test-svc-1.

Execute o job de treinamento na instância do Vertex AI Workbench.

No console do Google Cloud, acesse a guia "Instâncias" na página do Vertex AI Workbench.
Ao lado do nome da instância do Vertex AI Workbench (workbench-tutorial), clique em "Abrir JupyterLab". A instância do Vertex AI Workbench será aberta no JupyterLab.
Selecione Arquivo > Novo > Notebook
Selecione Kernel > Python 3
Em uma nova célula do notebook, execute o seguinte comando para garantir que você tenha a versão mais recente do pip:

! pip3 install --upgrade --quiet google-cloud-aiplatform \
  kfp \
  google-cloud-pipeline-components

Definir as variáveis do projeto na nova célula do notebook

PROJECT_ID = "<your-projectid>" 
REGION = "<your-region>"  
NETWORK_ATTACHMENT_NAME = "psc-network-attachment"

Exemplo:

PROJECT_ID = "psc-vertex" 
REGION = "us-central1"  
NETWORK_ATTACHMENT_NAME = "psc-network-attachment"

Definir um nome de bucket globalmente exclusivo como uma variável em uma nova célula do notebook

BUCKET_URI = f"gs://<your-bucket-name>"

Exemplo:

BUCKET_URI = f"gs://psc-vertex-bucket"

Em uma nova célula do notebook, crie o bucket

! gsutil mb -l {REGION} -p {PROJECT_ID} {BUCKET_URI}

Na seção a seguir, você vai determinar a conta de serviço padrão do Compute Engine a ser usada para executar o job do pipeline, além de conceder as permissões corretas a ela.

shell_output = ! gcloud projects describe $PROJECT_ID
PROJECT_NUMBER = shell_output[-1].split(":")[1].strip().replace("'", "")
SERVICE_ACCOUNT = f"{PROJECT_NUMBER}-compute@developer.gserviceaccount.com"

print(f"Project Number: {PROJECT_NUMBER}")
print(f"Service Account: {SERVICE_ACCOUNT}")

Para confirmar uma execução bem-sucedida, a conta de serviço e o número do projeto são impressos

Em uma nova célula do Bloco de notas, conceda à conta de serviço a permissão para ler e gravar artefatos de pipeline no bucket criado na etapa anterior.

! gsutil iam ch serviceAccount:{SERVICE_ACCOUNT}:roles/storage.objectCreator {BUCKET_URI}

! gsutil iam ch serviceAccount:{SERVICE_ACCOUNT}:roles/storage.objectViewer {BUCKET_URI}

Em uma nova célula do notebook, defina os parâmetros do pipeline. O NETWORK_ATTACHMENT_NAME é o anexo de rede do PSC e, portanto, precisa corresponder.

PIPELINE_ROOT = f"{BUCKET_URI}/pipeline_root/psc_test"
NETWORK_ATTACHMENT_URI = f"projects/{PROJECT_NUMBER}/regions/{REGION}/networkAttachments/{NETWORK_ATTACHMENT_NAME}"

Em uma nova célula do notebook, inicialize o SDK da Vertex AI

from kfp import dsl
from google.cloud import aiplatform, aiplatform_v1beta1
import time
from google.cloud.aiplatform_v1.types import pipeline_state
import yaml
from datetime import datetime
import logging
aiplatform.init(project=PROJECT_ID, location=REGION, staging_bucket=BUCKET_URI)

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

Em uma nova célula do notebook, defina o componente de teste

@dsl.container_component
def ping_check(network_address: str):
    """Pings a network address

    Args:
        network_address: The IP address to ping
    """

    return dsl.ContainerSpec(
        image="ubuntu:22.04",
        command=["sh", "-c"],
        args=[
            f"""
            
            # Use sed for regex replacement, cleaner than bash parameter expansion for this
            cleaned_address=$(echo "{network_address}" | sed 's/[^0-9.]//g')
            apt-get update && apt-get install inetutils-traceroute inetutils-ping -y
            
            echo "Will ping $cleaned_address"
            if ! ping -c 3 $cleaned_address; then
                echo "Ping failed"
                traceroute -w 1 -m 7 $cleaned_address
                exit 1
            fi
            """
        ],
    )

Em uma nova célula do notebook, defina o pipeline

@dsl.pipeline(name="check-connectivity")
def pipeline(ip_address: str):
    """Pings an IP address. Facilitated by a Private Service Connect Interface

    Args:
        ip_address: The IP address to ping
    """
    ping_check(network_address=ip_address).set_caching_options(False)
    return

Em uma nova célula do notebook, execute a função de utilitário e aguarde o pipeline terminar.

def wait_for_pipeline(
    project_id: str,
    region: str,
    pipeline_job_resource_name: str,
    timeout: int = 20 * 60,  # Default timeout of 20 minutes (in seconds)
) -> bool:
    """
    Waits for a Vertex AI pipeline to finish, with a timeout.

    Args:
        project_id (str): The Google Cloud project ID.
        region (str): The region where the pipeline is running.
        pipeline_job_resource_name (str): The resource name of the pipeline job.
        timeout (int): The maximum time to wait for the pipeline to finish, in seconds.
                       Defaults to 20 minutes (1200 seconds).

    Returns:
        bool: True if the pipeline succeeded, False otherwise.

    Raises:
        TimeoutError: If the pipeline does not finish within the specified timeout.
    """

    # Initialize the AIPlatform client
    aiplatform.init(project=project_id, location=region)

    # Get the pipeline job
    pipeline_job = aiplatform.PipelineJob.get(resource_name=pipeline_job_resource_name)
    logging.info(
        f"Vertex AI Console Link: https://console.cloud.google.com/vertex-ai/pipelines/locations/{region}/runs/{pipeline_job.resource_name.split('/')[-1]}?project={project_id}"
    )

    start_time = time.time()
    while True:
        status = pipeline_job.state
        logging.info(f"Pipeline Job status: {status.name}")

        if status in [
            pipeline_state.PipelineState.PIPELINE_STATE_SUCCEEDED,
            pipeline_state.PipelineState.PIPELINE_STATE_FAILED,
            pipeline_state.PipelineState.PIPELINE_STATE_CANCELLED,
        ]:
            break  # Exit the loop if the job is finished

        if time.time() - start_time > timeout:
            logging.error(f"Pipeline timed out after {timeout} seconds.")
            raise TimeoutError(f"Pipeline timed out after {timeout} seconds.")
        
        # Wait for a short time before checking again
        time.sleep(10)  # Adjust the wait time as needed

    # Do something based on the final status
    if status == pipeline_state.PipelineState.PIPELINE_STATE_SUCCEEDED:
        logging.info("Pipeline succeeded")
        return True
    elif status == pipeline_state.PipelineState.PIPELINE_STATE_CANCELLED:
        logging.error("Pipeline cancelled")
        raise Exception("Pipeline cancelled")
    elif status == pipeline_state.PipelineState.PIPELINE_STATE_FAILED:
        logging.error("Pipeline failed")
        raise Exception("Pipeline failed")

Em uma nova célula do notebook, execute a função de utilitário para executar o pipeline.

def run_job_with_psc_interface_config(
    project_id: str,
    region: str,
    pipeline_root: str,
    network_attachment_name: str,
    ip_address: str,
    local_pipeline_file: str = "pipeline.yaml",
):
    """
    Compiles, submits, and monitors a Vertex AI pipeline.
    """

    parameter_values = {"ip_address": ip_address}
    pipeline_root = f"{pipeline_root}/{datetime.now().strftime('%Y%m%d%H%M%S')}"
    logging.info("Compiling pipeline")

    try:
        with open(local_pipeline_file, "r") as stream:
            pipeline_spec = yaml.safe_load(stream)
            logging.info(f"Pipeline Spec: {pipeline_spec}")
    except yaml.YAMLError as exc:
        logging.error(f"Error loading pipeline yaml file: {exc}")
        raise
    
    logging.info(f"Will use pipeline root: {pipeline_root}")
    # Initialize the Vertex SDK using PROJECT_ID and LOCATION
    aiplatform.init(project=project_id, location=region)

    # Create the API endpoint
    client_options = {"api_endpoint": f"{region}-aiplatform.googleapis.com"}

    # Initialize the PipelineServiceClient
    client = aiplatform_v1beta1.PipelineServiceClient(client_options=client_options)

    # Construct the request
    request = aiplatform_v1beta1.CreatePipelineJobRequest(
        parent=f"projects/{project_id}/locations/{region}",
        pipeline_job=aiplatform_v1beta1.PipelineJob(
            display_name="pipeline-with-psc-interface-config",
            pipeline_spec=pipeline_spec,
            runtime_config=aiplatform_v1beta1.PipelineJob.RuntimeConfig(
                gcs_output_directory=pipeline_root, parameter_values=parameter_values
            ),
            psc_interface_config=aiplatform_v1beta1.PscInterfaceConfig(
                network_attachment=network_attachment_name
            ),
        ),
    )

    # Make the API call
    response = client.create_pipeline_job(request=request)

    # Print the response
    logging.info(f"Pipeline job created: {response.name}")

    return response.name

Em uma nova célula do notebook, compile o pipeline.

from kfp import compiler
compiler.Compiler().compile(pipeline_func=pipeline, package_path='pipeline.yaml')

Em uma nova célula do Bloco de notas, atualize TARGET_IP_ADDRESS para refletir o endereço IP obtido na etapa anterior para test-svc-1 e observe o status do job do pipeline.

TARGET_IP_ADDRESS = "<your-test-svc-1-ip>"
try:
    job_name = run_job_with_psc_interface_config(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_root=PIPELINE_ROOT,
        network_attachment_name=NETWORK_ATTACHMENT_URI,
        ip_address=TARGET_IP_ADDRESS,
    )
    wait_for_pipeline(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_job_resource_name=job_name,
    )
except Exception as e:
    logging.error(f"An error occurred: {e}")

Exemplo:

TARGET_IP_ADDRESS = "192.168.20.2"
try:
    job_name = run_job_with_psc_interface_config(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_root=PIPELINE_ROOT,
        network_attachment_name=NETWORK_ATTACHMENT_URI,
        ip_address=TARGET_IP_ADDRESS,
    )
    wait_for_pipeline(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_job_resource_name=job_name,
    )
except Exception as e:
    logging.error(f"An error occurred: {e}")

Depois que a etapa 17 for executada, o pipeline vai levar cerca de 8 minutos para ser concluído.

12. Validar a conectividade com test-svc-1

Na célula usada para executar a etapa 17, observe a transição do status do job do pipeline de PIPELINE_STATE_PENDING para PIPELINE_STATE_RUNNING e, por fim, PIPELINE_STATE_SUCCEEDED, que indica um ping bem-sucedido dos pipelines da Vertex AI e a resposta do test-svc-1.

Para validar o tráfego ICMP entre o Vertex AI Pipeline e o test-svc-1, consulte a sessão tcpdump gerada anteriormente executada no SO test-svc-1, que fornece registros indicando tráfego bidirecional.

No exemplo de tcpdump, os pipelines do Vertex AI extraíram o endereço IP 192.168.10.3 da sub-rede 192.168.10.0/28, 192.168.20.2 é o endereço IP de test-svc-1. No seu ambiente, os endereços IP podem ser diferentes.

user@test-svc-1:~$ sudo tcpdump -i any icmp -nn
tcpdump: data link type LINUX_SLL2
tcpdump: verbose output suppressed, use -v[v]... for full protocol decode
listening on any, link-type LINUX_SLL2 (Linux cooked v2), snapshot length 262144 bytes
18:57:54.737490 ens4  In  IP 192.168.10.3 > 192.168.20.2: ICMP echo request, id 257, seq 0, length 64
18:57:54.737523 ens4  Out IP 192.168.20.2 > 192.168.10.3: ICMP echo reply, id 257, seq 0, length 64

13. Vertex AI Pipelines AI para conectividade test-svc-2

Na próxima seção, você vai criar uma regra de firewall de entrada para negar o tráfego da sub-rede do Vertex AI Pipelines (192.168.10.0/28) para test-svc-2, depois atualizar o notebook para refletir o endereço IP do test-svc-2 e, por fim, executar a execução dos trabalhos do Pipelines.

Na célula do notebook, o status do job do pipeline vai indicar "Erro: falha no pipeline". Além disso, os registros do firewall vão fornecer insights sobre a conexão com falha.

Criar uma regra de firewall de negação de entrada

Para negar a conectividade dos pipelines do Vertex AI para o test-svc-2, crie uma regra de firewall de entrada que especifique o anexo de rede PSC como a origem (192.168.10.0/28) e o endereço IP test-svc-2 como o destino.

No Cloud Shell, atualize o destino para corresponder ao endereço IP test-svc-2.

gcloud compute --project=$projectid firewall-rules create deny-icmp-vertex-pipelines-to-test-svc2-vm --direction=INGRESS --priority=1000 --network=consumer-vpc --action=DENY  --source-ranges=192.168.10.0/28 --rules=ALL --destination-ranges=<your-test-svc-2-vm-ip> --rules=icmp --enable-logging

Exemplo:

gcloud compute --project=$projectid firewall-rules create deny-icmp-vertex-pipelines-to-test-svc2-vm --direction=INGRESS --priority=1000 --network=consumer-vpc --action=DENY  --source-ranges=192.168.10.0/28 --rules=ALL --destination-ranges=192.168.30.2 --enable-logging

Executar o job do pipeline na célula do notebook

Em uma nova célula do Bloco de notas, atualize TARGET_IP_ADDRESS para refletir o endereço IP obtido na etapa anterior para test-svc-2 e observe o status do job do pipeline.

TARGET_IP_ADDRESS = "<your-test-svc-2-ip>"
try:
    job_name = run_job_with_psc_interface_config(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_root=PIPELINE_ROOT,
        network_attachment_name=NETWORK_ATTACHMENT_URI,
        ip_address=TARGET_IP_ADDRESS,
    )
    wait_for_pipeline(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_job_resource_name=job_name,
    )
except Exception as e:
    logging.error(f"An error occurred: {e}")

Exemplo:

TARGET_IP_ADDRESS = "192.168.30.2"
try:
    job_name = run_job_with_psc_interface_config(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_root=PIPELINE_ROOT,
        network_attachment_name=NETWORK_ATTACHMENT_URI,
        ip_address=TARGET_IP_ADDRESS,
    )
    wait_for_pipeline(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_job_resource_name=job_name,
    )
except Exception as e:
    logging.error(f"An error occurred: {e}")

Depois de executado, o job do pipeline leva cerca de 8 minutos para ser concluído.

14. Validar a conectividade com falha para test-svc-2

Na célula usada para executar o job do Pipelines, observe a transição de status de PIPELINE_STATE_PENDING para PIPELINE_STATE_FAILED, indicando um ping com falha do Vertex AI Pipelines e a resposta do test-svc-2.

Com o Log Explorer, é possível conferir as entradas de registro de firewall que correspondem à regra de negação de entrada que consiste na sub-rede do Vertex AI Pipelines (192.168.10.0/28) e no endereço IP test-svc-2.

Selecione "Mostrar consulta" e insira o filtro abaixo, "Últimos 15 minutos", seguido por "Executar consulta".

jsonPayload.rule_details.reference:("network:consumer-vpc/firewall:deny-icmp-vertex-pipelines-to-test-svc2-vm")

Selecione uma entrada de registro e abra os campos aninhados para revelar elementos de informação que consistem nos Pipelines da Vertex AI e no endereço IP test-svc-2, validando a regra de firewall de entrada negada.

15. Limpar

No Cloud Shell, exclua os componentes do tutorial.

gcloud compute instances delete test-svc-1 test-svc-2 --zone=us-central1-a --quiet

gcloud workbench instances delete workbench-tutorial --location=us-central1-a --quiet

gcloud compute firewall-rules delete deny-icmp-vertex-pipelines-to-test-svc2-vm allow-icmp-vertex-pipelines-to-test-svc1-vm ssh-iap-consumer --quiet

gcloud compute routers nats delete cloud-nat-us-central1 --router=cloud-router-us-central1 --region us-central1 --quiet

gcloud compute routers delete cloud-router-us-central1 --region=us-central1 --quiet

16. Parabéns

Parabéns! Você configurou e validou uma interface do Private Service Connect e a conectividade do consumidor e do produtor implementando o firewall de permissão e negação de entrada.

Você criou a infraestrutura do consumidor e adicionou um anexo de rede que permitiu que o serviço Vertex AI Pipelines criasse uma VM de interface PSC para conectar a comunicação entre o consumidor e o produtor. Você aprendeu a criar regras de firewall na rede VPC consumidora que permitiam e negavam a conectividade às instâncias na rede consumidora.

Interface do Private Service Connect Vertex AI Pipelines

1. Introdução

O que você vai criar

O que você vai aprender

O que é necessário

2. Antes de começar

Atualizar o projeto para oferecer suporte ao tutorial

3. Configuração do consumidor

Criar a VPC do consumidor

Criar as sub-redes do consumidor

Configuração do Cloud Router e NAT

Criar a sub-rede de anexo de rede do Private Service Connect

4. Ativar o Identity-Aware Proxy (IAP)

5. Criar instâncias de VM do consumidor

6. Anexo de rede do Private Service Connect

Criar o anexo de rede

Listar os anexos de rede

Descrever os anexos de rede

7. Configuração do Vertex AI Workbench

Criar uma conta de serviço gerenciada pelo usuário

Criar uma instância do Vertex AI Workbench

8. Vertex AI Pipelines para conectividade test-svc-1

9. Atualização do agente de serviço da Vertex AI

10. Atualização da conta de serviço padrão

11. Implantar o job do Vertex AI Pipelines

12. Validar a conectividade com test-svc-1

13. Vertex AI Pipelines AI para conectividade test-svc-2

Criar uma regra de firewall de negação de entrada

Executar o job do pipeline na célula do notebook

14. Validar a conectividade com falha para test-svc-2

15. Limpar

16. Parabéns

Qual é a próxima etapa?

Mais leituras e vídeos

Documentos de referência