Interfejs Private Service Connect Vertex AI Pipelines

1. Wprowadzenie

Interfejs Private Service Connect to zasób, który umożliwia sieci prywatnego środowiska wirtualnego w chmurze producenta inicjowanie połączeń z różnymi miejscami docelowymi w sieci konsumenta. Sieci producenta i odbiorcy mogą znajdować się w różnych projektach i organizacjach.

Połączenie między przyłączem sieci a interfejsem Private Service Connect jest podobne do połączenia między punktem końcowym Private Service Connect a przyłączem usługi, ale ma 2 kluczowe różnice:

  • Przyłącze sieci umożliwia sieci producenta inicjowanie połączeń z siecią konsumenta (ruch wychodzący usługi zarządzanej), a punkt końcowy umożliwia sieci konsumenta inicjowanie połączeń z siecią producenta (ruch przychodzący usługi zarządzanej).
  • Połączenie interfejsu Private Service Connect jest przechodnie. Oznacza to, że sieć producenta może komunikować się z innymi sieciami połączonymi z siecią konsumenta.

Co utworzysz

Potoki Vertex AI wdrożone w projekcie najemcy zarządzanym przez Google będą korzystać z załącznika sieci PSC, aby utworzyć instancję z wieloma interfejsami sieciowymi między siecią producenta a siecią konsumenta. Przyłącze sieci PSC jest wdrażane z wieloma interfejsami sieciowymi z sieci konsumenta, więc Vertex AI Pipelines może docierać do tras dostępnych w sieci konsumenta.

W tym samouczku utworzysz kompleksową architekturę interfejsu Private Service Connect (PSC) dla Vertex AI Pipelines, która wykorzystuje reguły zapory sieciowej Cloud do zezwalania na połączenia z instancji testowych producenta do konsumenta lub odmawiania ich, jak pokazano na rysunku 1.

Rysunek 1.

12714b6f0f8fa411.png

W sieci VPC konsumenta utworzysz jedno przyłącze sieci psc, co umożliwi Ci korzystanie z tych przypadków użycia:

  1. Utwórz regułę zapory sieciowej dla ruchu przychodzącego w sieci consumer-vpc, która zezwala podsieci Vertex AI Pipeline (192.168.10.0/28) na dostęp do usługi test-svc-1. Potwierdź, że zadanie w potoku wygenerowało PING do test-svc-1 za pomocą narzędzia TCPDUMP
  2. Utwórz regułę zapory sieciowej dla ruchu przychodzącego w sieci consumer-vpc, która odrzuca ruch z podsieci Vertex AI Pipeline (192.168.10.0/28) do usługi test-svc-2. Potwierdź niepowodzenie polecenia PING na podstawie logów zapory sieciowej wygenerowanych przez eksplorator logów.

Czego się nauczysz

  • Tworzenie przyłącza sieci
  • Jak Vertex AI Pipelines może używać przyłącza sieciowego do tworzenia interfejsu PSC
  • Jak nawiązać komunikację między producentem a konsumentem
  • Jak zezwolić na dostęp z Vertex AI Pipelines do maszyny wirtualnej konsumenta test-svc-1
  • Jak za pomocą zapory sieciowej Cloud odmówić dostępu z Vertex AI Pipelines do maszyny wirtualnej klienta test-svc-2

Czego potrzebujesz

2. Zanim zaczniesz

W tym samouczku używamy zmiennych $variables, aby ułatwić implementację konfiguracji gcloud w Cloud Shell.

W Cloud Shell wykonaj te czynności:

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

Aktualizowanie projektu na potrzeby samouczka

W Cloud Shell wykonaj te czynności:

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. Konfiguracja konsumencka

Tworzenie sieci VPC konsumenta

W Cloud Shell wykonaj te czynności:

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

Tworzenie podsieci konsumenta

W Cloud Shell wykonaj te czynności:

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

W Cloud Shell wykonaj te czynności:

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

W Cloud Shell wykonaj te czynności:

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

Konfiguracja routera Cloud Router i NAT

W samouczku używamy Cloud Network Address Translation (NAT) do pobierania pakietów oprogramowania notebooka, ponieważ instancja notebooka nie ma zewnętrznego adresu IP. Cloud NAT oferuje funkcje NAT ruchu wychodzącego, co oznacza, że hosty internetowe nie mogą inicjować komunikacji z notatnikiem zarządzanym przez użytkownika, co zwiększa bezpieczeństwo.

W Cloud Shell utwórz regionalny router Cloud Router.

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

W Cloud Shell utwórz regionalną bramę 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

Utwórz podsieć przyłącza sieci Private Service Connect

W Cloud Shell utwórz podsieć Network Attachment używaną przez 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. Włączanie serwera proxy identyfikującego tożsamość (IAP)

Aby umożliwić IAP połączenie z instancjami maszyn wirtualnych, utwórz regułę zapory sieciowej, która:

  • Dotyczy wszystkich instancji maszyn wirtualnych, które mają być dostępne przez IAP.
  • Zezwala na ruch przychodzący z zakresu adresów IP 35.235.240.0/20. Ten zakres zawiera wszystkie adresy IP, których IAP używa do przekierowywania TCP.

W Cloud Shell utwórz regułę zapory sieciowej IAP.

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

5. Tworzenie instancji maszyn wirtualnych konsumentów

W Cloud Shell utwórz instancję maszyny wirtualnej klienta 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

W Cloud Shell utwórz instancję maszyny wirtualnej klienta 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

Uzyskaj i zapisz adresy IP instancji:

W Cloud Shell wykonaj opis instancji testowych maszyn wirtualnych.

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:

Przykład:

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. Przyłącze sieci Private Service Connect

Przyłącza sieci to zasoby regionalne, które reprezentują stronę konsumenta interfejsu Private Service Connect. Z przyłączem sieci wiążesz jedną podsieć, a producent (Vertex AI Pipelines) przypisuje adresy IP do interfejsu Private Service Connect.

Tworzenie przyłącza sieci

W Cloud Shell utwórz przyłącze sieci.

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

Wyświetlanie listy przyłączy sieci

W Cloud Shell wyświetl listę przyłączy sieci.

gcloud compute network-attachments list

Opisz przyłącza sieci

W Cloud Shell opisz przyłącze sieci.

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

Zanotuj identyfikator URI psc-network-attachment, który będzie używany przez producenta podczas tworzenia interfejsu Private Service Connect.

W przykładzie poniżej identyfikator URI przyłącza sieci PSC jest następujący:

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. Konfiguracja Vertex AI Workbench

W sekcji poniżej znajdziesz instrukcje tworzenia notatnika Jupyter. Ten notatnik zostanie użyty do wdrożenia zadania Pipelines, które wysyła polecenie PING z Vertex AI Pipelines do instancji testowych. Ścieżka danych między Vertex AI Pipelines a siecią konsumenta zawierającą instancje korzysta z interfejsu sieciowego Private Service Connect.

Tworzenie konta usługi zarządzanego przez użytkownika

W następnej sekcji utworzysz konto usługi, które będzie powiązane z instancją Vertex AI Workbench używaną w tym samouczku.

W tym samouczku do konta usługi zostaną przypisane te role:

W Cloud Shell utwórz konto usługi.

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

W Cloud Shell zaktualizuj konto usługi, przypisując mu rolę Administrator miejsca na dane.

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

W Cloud Shell zaktualizuj konto usługi, przypisując mu rolę Użytkownik Vertex AI.

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

W Cloud Shell zaktualizuj konto usługi, przypisując mu rolę Administrator Artifact Registry.

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

W Cloud Shell zezwól kontu usługi notatnika na używanie domyślnego konta usługi Compute Engine do tworzenia instancji zadania potoku.

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"

Tworzenie instancji Vertex AI Workbench

W sekcji poniżej utwórz instancję Vertex AI Workbench, która zawiera utworzone wcześniej konto usługi notebook-sa.

W Cloud Shell utwórz instancję 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. Połączenie Vertex AI Pipelines z usługą test-svc-1

Otwórz nową kartę Cloud Shell i zaktualizuj ustawienia projektu.

W Cloud Shell wykonaj te czynności:

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

Aby zezwolić na połączenie z Vertex AI Pipelines z usługą test-svc-1, utwórz regułę zapory sieciowej zezwalającą na ruch przychodzący, która określa przyłączenie sieci PSC jako źródło (192.168.10.0/28), a adres IP usługi test-svc-1 jako miejsce docelowe.

W Cloud Shell zaktualizuj zakres docelowy, aby pasował do adresu 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

Przykład:

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

Zaloguj się w instancji test-svc-1 za pomocą IAP w Cloud Shell.

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

W systemie operacyjnym uruchom tcpdump, aby przechwycić cały ruch ICMP. Ta sesja systemu operacyjnego będzie używana do weryfikowania komunikacji między potokiem Vertex AI a maszyną wirtualną.

sudo tcpdump -i any icmp -nn

9. Aktualizacja agenta usługi Vertex AI

Vertex AI Pipelines działa w Twoim imieniu, wykonując operacje takie jak uzyskiwanie adresu IP z podsieci przyłącza sieci PSC używanej do tworzenia interfejsu PSC. W tym celu Vertex AI Pipelines używa agenta usługi (wymienionego poniżej), który wymaga uprawnień administratora sieci.

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

W Cloud Shell uzyskaj numer projektu.

gcloud projects describe $projectid | grep projectNumber

Przykład:

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

W Cloud Shell zaktualizuj konto agenta usługi, przypisując mu rolę compute.networkAdmin.

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

Przykład:

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

10. Aktualizacja domyślnego konta usługi

Włącz interfejs Compute Engine API i przyznaj domyślnemu kontu usługi dostęp do Vertex AI. Pamiętaj, że zanim zmiana dostępu zostanie zastosowana, może minąć trochę czasu.

W Cloud Shell zaktualizuj domyślne konto usługi, przypisując mu rolę aiplatform.user.

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

Przykład:

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

11. Wdrażanie zadania potoku Vertex AI

W następnej sekcji utworzysz notatnik, aby wykonać polecenie PING na instancji test-svc-1.

Uruchom zadanie trenowania w instancji Vertex AI Workbench.

  1. W konsoli Google Cloud otwórz kartę instancji na stronie Vertex AI Workbench.
  2. Obok nazwy instancji Vertex AI Workbench (workbench-tutorial) kliknij Otwórz JupyterLab. Instancja Vertex AI Workbench otworzy się w JupyterLab.
  3. Wybierz Plik > Nowy > Notatnik.
  4. Wybierz Jądro > Python 3.
  5. W nowej komórce notatnika uruchom to polecenie, aby upewnić się, że masz najnowszą wersję pip:
! pip3 install --upgrade --quiet google-cloud-aiplatform \
  kfp \
  google-cloud-pipeline-components
  1. Ustaw zmienne projektu w nowej komórce notatnika
PROJECT_ID = "<your-projectid>" 
REGION = "<your-region>"  
NETWORK_ATTACHMENT_NAME = "psc-network-attachment"

Przykład:

PROJECT_ID = "psc-vertex" 
REGION = "us-central1"  
NETWORK_ATTACHMENT_NAME = "psc-network-attachment"
  1. Zdefiniuj globalnie unikalną nazwę zasobnika jako zmienną w nowej komórce notatnika.
BUCKET_URI = f"gs://<your-bucket-name>"

Przykład:

BUCKET_URI = f"gs://psc-vertex-bucket"
  1. Utwórz zasobnik w nowej komórce notatnika.
! gsutil mb -l {REGION} -p {PROJECT_ID} {BUCKET_URI}

W następnej sekcji określisz domyślne konto usługi Compute Engine, które będzie używane do uruchamiania zadania potoku, i przyznasz mu odpowiednie uprawnienia.

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}")

Aby potwierdzić pomyślne wykonanie, wydrukujemy Twoje konto usługi i numer projektu.

  1. W nowej komórce notatnika przyznaj kontu usługi uprawnienia do odczytu i zapisu artefaktów potoku w zasobniku utworzonym w poprzednim kroku.
! gsutil iam ch serviceAccount:{SERVICE_ACCOUNT}:roles/storage.objectCreator {BUCKET_URI}

! gsutil iam ch serviceAccount:{SERVICE_ACCOUNT}:roles/storage.objectViewer {BUCKET_URI}
  1. W nowej komórce notatnika zdefiniuj parametry potoku. Pamiętaj, że NETWORK_ATTACHMENT_NAME to przyłącze sieci PSC, więc musi być zgodne.
PIPELINE_ROOT = f"{BUCKET_URI}/pipeline_root/psc_test"
NETWORK_ATTACHMENT_URI = f"projects/{PROJECT_NUMBER}/regions/{REGION}/networkAttachments/{NETWORK_ATTACHMENT_NAME}"
  1. W nowej komórce notatnika zainicjuj pakiet Vertex AI SDK.
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')
  1. W nowej komórce notatnika zdefiniuj komponent testowy.
@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
            """
        ],
    )
  1. W nowej komórce notatnika zdefiniuj potok.
@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
  1. W nowej komórce notatnika wykonaj funkcję użytkową i poczekaj na zakończenie potoku.
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")
  1. W nowej komórce notatnika wykonaj funkcję użytkową, aby uruchomić potok.
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
  1. W nowej komórce notatnika skompiluj potok.
from kfp import compiler
compiler.Compiler().compile(pipeline_func=pipeline, package_path='pipeline.yaml')
  1. W nowej komórce notatnika zaktualizuj zmienną TARGET_IP_ADDRESS, aby odzwierciedlała adres IP uzyskany w poprzednim kroku dla usługi test-svc-1, i sprawdź stan zadania potoku.
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}")

Przykład:

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}")

Po wykonaniu kroku 17 potok będzie działać jeszcze przez około 8 minut.

12. Sprawdzanie połączenia z test-svc-1

W komórce użytej do wykonania kroku 17 obserwuj przejście stanu zadania potoku z PIPELINE_STATE_PENDING na PIPELINE_STATE_RUNNING, a następnie na PIPELINE_STATE_SUCCEEDED, co oznacza, że ping z Vertex AI Pipelines i odpowiedź z test-svc-1 zostały wysłane i odebrane.

Aby sprawdzić ruch ICMP między potokiem Vertex AI a usługą test-svc-1, wyświetl wcześniej wygenerowaną sesję tcpdump uruchomioną w systemie operacyjnym usługi test-svc-1, która zawiera logi wskazujące ruch dwukierunkowy.

W przykładzie tcpdump potok Vertex AI Pipelines pobrał adres IP 192.168.10.3 z podsieci 192.168.10.0/28, a 192.168.20.2 to adres IP usługi test-svc-1. Pamiętaj, że w Twoim środowisku adresy IP mogą się różnić.

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. Łączność Vertex AI Pipelines AI z usługą test-svc-2

W sekcji poniżej utworzysz regułę zapory sieciowej zezwalającą na ruch przychodzący, aby odrzucić ruch z podsieci Vertex AI Pipelines (192.168.10.0/28) do test-svc-2. Następnie zaktualizujesz notatnik, aby odzwierciedlał adres IP test-svc-2, i na koniec wykonasz zadania Pipelines.

W komórce notatnika stan zadania potoku będzie wskazywać błąd – niepowodzenie potoku. Dodatkowo dzienniki zapory sieciowej będą zawierać informacje o nieudanym połączeniu.

Tworzenie reguły zapory sieciowej dotyczącej blokowania ruchu przychodzącego

Aby odmówić połączenia z Vertex AI Pipelines z usługą test-svc-2, utwórz regułę zapory sieciowej wchodzącej, która określa przyłączenie sieci PSC jako źródło (192.168.10.0/28), a adres IP usługi test-svc-2 jako miejsce docelowe.

W Cloud Shell zaktualizuj zakres docelowy, aby pasował do adresu IP usługi 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

Przykład:

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

Wykonywanie zadania potoku z komórki notatnika

W nowej komórce notatnika zaktualizuj zmienną TARGET_IP_ADDRESS, aby odzwierciedlała adres IP uzyskany w poprzednim kroku dla usługi test-svc-2, i obserwuj stan zadania 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}")

Przykład:

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}")

Po wykonaniu zadanie potoku zajmie około 8 minut.

14. Nie udało się zweryfikować połączenia z test-svc-2

W komórce użytej do wykonania zadania Pipelines zwróć uwagę na przejście stanu z PIPELINE_STATE_PENDING na PIPELINE_STATE_FAILED, co oznacza nieudaną próbę pingowania z Vertex AI Pipelines i odpowiedź z test-svc-2.

Za pomocą Eksploratora logów możesz wyświetlić wpisy logowania zapory sieciowej pasujące do reguły odrzucania ruchu przychodzącego, która składa się z podsieci Vertex AI Pipelines (192.168.10.0/28) i adresu IP test-svc-2.

Wybierz Pokaż zapytanie i wstaw poniższy filtr: ostatnie 15 minut, a potem kliknij Uruchom zapytanie.

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

20e072f26d9a113b.png

5fb3d2de0a85e3c6.png

Wybierz wpis logu, a następnie rozwiń zagnieżdżone pola, aby wyświetlić elementy informacji składające się z adresu IP Vertex AI Pipelines i test-svc-2, które potwierdzają odrzuconą regułę zapory sieciowej ruchu przychodzącego.

903aaf2c10d07460.png

15. Czyszczenie danych

W Cloud Shell usuń komponenty samouczka.

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. Gratulacje

Gratulacje. Udało Ci się skonfigurować i zweryfikować interfejs Private Service Connect oraz połączenie konsumenta i producenta przez wdrożenie zapory sieciowej zezwalającej i odmawiającej dostęp.

Utworzono infrastrukturę konsumenta i dodano przyłącze sieci, które umożliwiło usłudze Vertex AI Pipelines utworzenie maszyny wirtualnej interfejsu PSC, aby połączyć komunikację konsumenta i producenta. Dowiedzieliśmy się, jak tworzyć reguły zapory sieciowej w sieci VPC klienta, które zezwalały na połączenia z instancjami w sieci klienta i je blokowały.

Cosmopup uważa, że samouczki są świetne!!

c911c127bffdee57.jpeg

Co dalej?

Więcej informacji i filmy

Dokumentacja