Interfejs Private Service Connect Vertex AI Pipelines

1. Wprowadzenie

Interfejs Private Service Connect to zasób, który umożliwia sieci prywatnego środowiska wirtualnego (VPC) producenta inicjowanie połączeń z różnymi miejscami docelowymi w sieci konsumenta. Sieci producentów i konsumentów mogą należeć do różnych projektów i organizacji.

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 dwie główne różnice:

  • Przyłącze sieci umożliwia sieci producenta inicjowanie połączeń z siecią konsumenta (wychodzące usługi zarządzane), a punkt końcowy umożliwia sieci konsumenta inicjowanie połączeń z siecią producenta (wejściowe usługi zarządzane).
  • 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, wdrażane w projekcie klienta zarządzanym przez Google, będą korzystać z załącznika sieci PSC do tworzenia instancji z wieloma adresami IP między siecią producenta a siecią konsumenta. Ponieważ przyłącze sieci PSC jest wdrażane z multi-nic z sieci konsumenta, Vertex AI Pipelines może uzyskiwać dostęp do tras dostępnych w sieci konsumenta.

W tym samouczku utworzysz kompleksową architekturę interfejsu Private Service Connect (PSC) dla przepływów Vertex AI, która wykorzystuje reguły zapory Cloud Firewall do zezwalania lub odmowy zezwolenia na połączenie między producentem a instancjami testowymi konsumenta, jak pokazano na rysunku 1.

Rysunek 1.

12714b6f0f8fa411.png

W VPC konsumenta utworzysz pojedynczy załącznik psc-network, który będzie miał zastosowanie w następujących przypadkach:

  1. Utwórz regułę zapory sieciowej Ingress 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. Upewnij się, że za pomocą TCPDUMP-a PING został wygenerowany przez zadanie w pipeline’ie do test-svc-1.
  2. Utwórz regułę zapory sieciowej Ingress w sieci consumer-vpc, która odmawia dostępu podsieci Vertex AI Pipeline (192.168.10.0/28) do usługi test-svc-2. Sprawdź, czy błąd PING występuje na podstawie logów zapory sieciowej wygenerowanych przez Eksploratora logów.

Czego się nauczysz

  • Tworzenie przyłącza sieci
  • Jak Vertex AI Pipelines może użyć załącznika sieci do utworzenia interfejsu PSC
  • Jak nawiązać komunikację między producentem a konsumentem
  • Jak zezwolić Vertex AI Pipelines na dostęp do maszyny wirtualnej konsumenta test-svc-1
  • Jak za pomocą zapory sieciowej Cloud Firewall odmówić dostępu ścieżkom Verex AI do maszyny wirtualnej dla 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 w celu obsługi 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 przez konsumenta

Tworzenie środowiska VPC konsumenta

W Cloud Shell wykonaj te czynności:

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

Tworzenie podsieci dla użytkowników

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 Cloud Router i NAT

W samouczku dotyczącym pobierania pakietów oprogramowania notebooka używamy usługi Cloud Network Address Translation (NAT), ponieważ instancja notebooka nie ma zewnętrznego adresu IP. Cloud NAT oferuje możliwości NAT wychodzącego, co oznacza, że hosty internetowe nie mogą nawiązywać komunikacji z notebookiem 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ę NAT w chmurze.

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

Tworzenie podsieci przyłącza sieci Private Service Connect

W Cloud Shell utwórz podsieć sieciową załącznika sieciowego 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 dla użytkowników

W Cloud Shell utwórz instancję maszyny wirtualnej dla konsumenta o nazwie 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 dla konsumenta o nazwie 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

Pobierz i zapisz adresy IP instancji:

W Cloud Shell wykonaj polecenie describe dla testowych instancji 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. Pojedynczy przedział adresów IP zostaje powiązany z przyłączem sieci, 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

Lista 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 URI psc-network-attachment, którego producent będzie używać podczas tworzenia interfejsu Private Service Connect.

W przykładzie poniżej identyfikator URI załącznika sieci PSC ma postać:

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

W tej sekcji znajdziesz instrukcje tworzenia notatek Jupyter. Ten notebook posłuży do wdrożenia zadania Pipelines, które wysyła sygnał PING z Vertex AI Pipelines do instancji testowych. Ścieżka danych między ścieżkami Vertex AI a siecią konsumenta zawierającą instancje korzysta z interfejsu sieci 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 samouczku konto usługi będzie miało 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, nadając mu rolę administratora 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ę Administratora rejestru artefaktów.

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

W Cloud Shell zezwól, aby konto usługi notatnika używało domyślnego konta usługi Compute Engine do tworzenia instancji zadania w ramach procesu.

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 następnej sekcji utwórz instancję Vertex AI Workbench, która zawiera utworzone wcześniej konto usługi notebook-sa.

W Cloud Shell utwórz instancję klienta prywatnego.

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. Łączność Vertex AI Pipelines z 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 umożliwić połączenia z Vertex AI Pipelines z usługą test-svc-1, utwórz reguły zapory sieciowej dla przychodzących połączeń, które jako źródło wskazują załącznik sieciowy PSC (192.168.10.0/28), a jako miejsce docelowe adres IP usługi test-svc-1.

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ę do 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ć ruch ICMP. Ta sesja systemu operacyjnego posłuży do sprawdzenia komunikacji między Vertex AI Pipeline 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, która służy do tworzenia interfejsu PSC. W tym celu Vertex AI Pipelines używa agenta usługi (wymienionego poniżej), który wymaga uprawnienia Administrator 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 może minąć trochę czasu, zanim zmiana dostępu zostanie rozpowszechniona.

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 Vertex AI Pipelines

W tej sekcji utworzysz notebook, który umożliwi pingowanie instancji test-svc-1 dla użytkowników.

Uruchom zadanie treningowe w instancji Vertex AI Workbench.

  1. W konsoli Google Cloud otwórz stronę Workbench Vertex AI i przejdź na kartę instancji.
  2. Obok nazwy instancji Vertex AI Workbench (workbench-tutorial) kliknij Otwórz JupyterLab. Twoja instancja Vertex AI Workbench otworzy się w JupyterLab.
  3. Kliknij Plik > Nowy > Notatnik.
  4. Wybierz Jądro > Python 3.
  5. Aby sprawdzić, czy masz najnowszą wersję pip, uruchom to polecenie w nowej komórce w notatniku:
! 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 niepowtarzalną 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. W nowej komórce notatnika utwórz zasobnik
! 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 wykonywania zadań potoku, oraz 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, wydrukuj konto usługi i numer projektu

  1. W nowej komórce w notatniku przyznaj swojemu 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 załącznik sieci PSC, więc musi być zgodny.
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 w notatniku 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. Zdefiniuj komponent testowy w nowej komórce notatnika
@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. Zdefiniuj potok w nowej komórce notatnika
@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ę pomocniczą i poczekaj, aż rurociąg się zakończy
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 notebooka wykonaj funkcję pomocniczą, 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 w notatniku zaktualizuj wartość TARGET_IP_ADDRESS, aby odzwierciedlała adres IP uzyskany w poprzednim kroku dla test-svc-1, i obserwuj stan zadania w ramach 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 zostanie ukończony w ciągu około 8 minut.

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

W komórce użytej do wykonania kroku 17 zwróć uwagę na przejście stanu zadania w potoku z PIPELINE_STATE_PENDING na PIPELINE_STATE_RUNNING, a potem na PIPELINE_STATE_SUCCEEDED, co wskazuje na pomyślne wysłanie pinga z Vertex AI Pipelines i odpowiedź z test-svc-1.

Aby zweryfikować ruch ICMP między Vertex AI Pipeline a usługą test-svc-1, wyświetl wygenerowaną wcześniej sesję tcpdump wykonaną w systemie operacyjnym test-svc-1, która zawiera dzienniki wskazujące na ruch dwukierunkowy.

W przykładzie tcpdump Vertex AI Pipelines pobiera adres IP 192.168.10.3 z podsieci 192.168.10.0/28, a 192.168.20.2 to adres IP 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. Vertex AI Pipelines AI do test-svc-2 łączność

W następnej sekcji utworzysz regułę zapory sieciowej dla ruchu przychodzącego, aby odrzucić ruch z podsieci Vertex AI Pipelines (192.168.10.0/28) do usługi test-svc-2. Następnie zaktualizujesz Notebooka, aby odzwierciedlał adres IP usługi test-svc-2, a na koniec wykonasz zadania Pipelines.

W komórce Notebook stan zadania w ścieżce będzie wskazywać błąd – ścieżka nie powiodła się. Ponadto dzienniki zapory sieciowej będą zawierać informacje o nieudanym połączeniu.

Tworzenie reguły zapory sieciowej blokującej ruch przychodzący

Aby zablokować połączenia z Vertex AI Pipelines z usługą test-svc-2, utwórz reguły zapory sieciowej dla przychodzących połączeń, które jako źródło (192.168.10.0/28) wskazują załącznik sieciowy PSC, a jako docelowe – adres IP test-svc-2.

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

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 notebooka zaktualizuj wartość TARGET_IP_ADDRESS, aby odzwierciedlała adres IP uzyskany w poprzednim kroku dla test-svc-2, i obserwuj stan zadania w 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}")

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. Sprawdzanie nieudanego połączenia z test-svc-2

W komórce używanej do wykonywania zadania w ścieżce zwróć uwagę na przejście stanu z PIPELINE_STATE_PENDING do PIPELINE_STATE_FAILED, co wskazuje na nieudane wysłanie zapytania ping przez Vertex AI Pipelines i odpowiedź z test-svc-2.

Za pomocą narzędzia Log Explorer możesz wyświetlać wpisy logowania zapory sieciowej pasujące do reguły odmowy dostępu, 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 filtr poniżej, Ostatnie 15 minut, a następnie Uruchom zapytanie.

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

20e072f26d9a113b.png

5fb3d2de0a85e3c6.png

Wybierz wpis dziennika, a następnie rozwiń osadzone pola, aby wyświetlić elementy informacji z Vertex AI Pipelines i adresem IP test-svc-2, które weryfikują odrzuconą regułę zapory ogniowej.

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! Dzięki zaimplementowaniu reguł zapory sieciowej zezwalających i odmawiających dostępu udało Ci się skonfigurować i potwierdzić interfejs Private Service Connect oraz łączność konsumenta i producenta.

Utworzyłeś infrastrukturę dla konsumentów i dodałeś przyłącze sieciowe, które umożliwiło usłudze Vertex AI Pipelines utworzenie maszyny wirtualnej interfejsu PSC w celu połączenia komunikacji konsumenta i producenta. Dowiedz się, jak utworzyć reguły zapory sieciowej w sieci VPC konsumenta, które zezwalają na połączenia z instancjami w sieci konsumenta lub je blokują.

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

c911c127bffdee57.jpeg

Co dalej?

Więcej informacji i filmy

Dokumenty referencyjne