1. Introdução
A interface do Private Service Connect é um recurso que permite que uma rede de nuvem privada virtual (VPC, na sigla em inglês) do produtor inicie conexões com vários destinos em uma rede do 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 principais:
- 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, aproveita o anexo de rede PSC para criar uma instância de várias NICs entre a rede produtora e a consumidora. Como o anexo de rede do PSC é implantado com várias NICs da rede do consumidor, o Vertex AI Pipelines pode alcançar as rotas disponíveis na rede do consumidor.
Neste tutorial, você vai criar uma arquitetura abrangente de interface do Private Service Connect (PSC) para o Vertex AI Pipelines que usa 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 consumer-vpc que permita que a sub-rede do Vertex AI Pipeline (192.168.10.0/28) acesse test-svc-1. Confirme se o PING gerado do trabalho do pipeline para test-svc-1 foi bem-sucedido usando o TCPDUMP
- Crie uma regra de firewall de entrada na consumer-vpc negando a sub-rede do pipeline da Vertex AI (192.168.10.0/28) para test-svc-2. Confirme a falha de PING com base nos registros de firewall gerados pela Análise de registros.
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 Vertex AI Pipelines à VM do consumidor, test-svc-2, usando o Cloud Firewall
O que é necessário
- Projeto do Google Cloud
- Permissões do IAM
- Administrador da instância do Compute (roles/compute.instanceAdmin)
- Administrador de rede do Compute (roles/compute.networkAdmin)
- Administrador de segurança do Compute (roles/compute.securityAdmin)
- Usuário do túnel protegido pelo IAP (roles/iap.tunnelResourceAccessor)
- Administrador do Logging (roles/logging.admin)
- Administrador do Notebooks (roles/notebooks.admin)
- Administrador IAM do projeto (roles/resourcemanager.projectIamAdmin)
- Administrador de cotas (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 do NAT
A conversão de endereços de rede (NAT) do Cloud é usada no tutorial para downloads de pacotes de software de notebook porque a instância do 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 de VM que você quer acessar 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 nas 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 (Vertex AI Pipelines) 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 do PSC é:
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 notebook do Jupyter. 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 do consumidor 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 seção a seguir, você vai criar uma conta de serviço que será associada à instância do Vertex AI Workbench usada no tutorial.
No tutorial, a conta de serviço terá os seguintes papéis aplicados:
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 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 trabalho 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 private-client.
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. Conectividade do Vertex AI Pipelines com 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 Vertex AI Pipelines com o test-svc-1, crie uma regra de firewall de entrada que especifique a vinculação de rede do PSC como origem (192.168.10.0/28) e o endereço IP do test-svc-1 como destino.
No Cloud Shell, atualize o destination-range para corresponder ao endereço IP de 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 Vertex AI Pipeline e a VM.
sudo tcpdump -i any icmp -nn
9. Atualização do agente de serviço da Vertex AI
O Vertex AI Pipelines age em seu nome para realizar operações como a obtenção de 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 de administrador de rede.
service-$projectnumber@gcp-sa-aiplatform.iam.gserviceaccount.com
No Cloud Shell, recupere 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 do agente de serviço com a função 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 a função 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 um job do Vertex AI Pipelines
Na seção a seguir, você vai criar um notebook para realizar um PING bem-sucedido na instância consumer 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
- Defina 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 de notebook
BUCKET_URI = f"gs://<your-bucket-name>"
Exemplo:
BUCKET_URI = f"gs://psc-vertex-bucket"
- Em uma nova célula de 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 e 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, sua conta de serviço e o número do projeto são impressos
- Em uma nova célula do notebook, conceda à sua conta de serviço 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 utilitária e aguarde a conclusão do pipeline.
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 utilitária 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 notebook, atualize o 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, o que indica um ping bem-sucedido dos pipelines da Vertex AI e uma resposta de test-svc-1.
Para validar o tráfego ICMP entre o pipeline da Vertex AI e o test-svc-1, confira a sessão tcpdump gerada anteriormente executada no SO test-svc-1, que fornece registros indicando tráfego bidirecional.
No exemplo tcpdump, o Vertex AI Pipelines originou o endereço IP 192.168.10.3 da sub-rede 192.168.10.0/28, e 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. Conectividade da IA do Vertex AI Pipelines com test-svc-2
Na seção a seguir, 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, vai atualizar o notebook para refletir o endereço IP de test-svc-2 e, por fim, executar a execução dos jobs 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 da Vertex AI com test-svc-2, crie uma regra de firewall de entrada que especifique a conexão de rede PSC como origem (192.168.10.0/28) e o endereço IP test-svc-2 como destino.
No Cloud Shell, atualize o destination-range para corresponder ao endereço IP de 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 job do pipeline na célula do notebook
Em uma nova célula do notebook, atualize o TARGET_IP_ADDRESS para refletir o endereço IP obtido na etapa anterior para test-svc-2 e observe o status do job do Pipelines.
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 falha na conectividade com 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 sem sucesso do Vertex AI Pipelines e uma resposta de test-svc-2.
Com o Explorador de registros, é possível ver as entradas de geração de registros do 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 de "Executar consulta".
jsonPayload.rule_details.reference:("network:consumer-vpc/firewall:deny-icmp-vertex-pipelines-to-test-svc2-vm")
Selecione uma entrada de registro e expanda os campos aninhados para revelar elementos de informação que consistem no endereço IP do Vertex AI Pipelines e do 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 do Vertex AI Pipelines criasse uma VM de interface do PSC para fazer a ponte entre a comunicação do consumidor e do produtor. Você aprendeu a criar regras de firewall na rede VPC consumidora que permitiam e negavam a conectividade com as instâncias na rede consumidora.
A Cosmopup acha que os tutoriais são incríveis!
