Private Service Connect を使用してオンプレミスからトレーニングパイプラインにアクセスする

Vertex AI Pipelines は、Google Cloud Platform でエンドツーエンドの ML ワークフローを構築、デプロイ、管理するのに役立つマネージドサービスです。パイプラインを実行するためのサーバーレス環境が提供されるため、インフラストラクチャの管理に悩む必要はありません。

このチュートリアルでは、Vertex AI Pipelines を使用してカスタムトレーニングジョブを実行し、トレーニング済みモデルをハイブリッドネットワーク環境の Vertex AI にデプロイします。

プロセス全体が完了するまでに 2～3 時間かかります。これには、パイプラインの実行にかかる時間（約 50 分）も含まれます。

このチュートリアルは、Vertex AI、Virtual Private Cloud（VPC）、 Google Cloud コンソール、Cloud Shell に精通している企業のネットワーク管理者、データサイエンティスト、研究者を対象としています。Vertex AI Workbench の使用経験があると役立ちますが、必須ではありません。

Private Service Connect を使用してトレーニングパイプラインにアクセスするアーキテクチャ図。

目標

2 つの Virtual Private Cloud（VPC）ネットワークを作成します。
- 1 つ（vertex-networking-vpc）は、Vertex AI Pipelines API を使用して、ML モデルをトレーニングしてエンドポイントにデプロイするためのパイプラインテンプレートを作成してホストします。
- もう 1 つ（onprem-dataservice-vpc）は、オンプレミスネットワークを表します。
次のように 2 つの VPC ネットワークを接続します。
- HA VPN ゲートウェイ、Cloud VPN トンネル、Cloud Router をデプロイして、vertex-networking-vpc と onprem-dataservice-vpc に接続します。
- 限定公開のリクエストを Vertex AI Pipelines REST API に転送する Private Service Connect（PSC）エンドポイントを作成します。
- Private Service Connect エンドポイントのルートを onprem-dataservice-vpc に通知するために、vertex-networking-vpc に Cloud Router のカスタムルートアドバタイズを構成します。
onprem-dataservice-vpc VPC ネットワークに Filestore インスタンスを作成し、そこに NFS 共有でトレーニングデータを追加します。
トレーニングジョブ用の Python パッケージアプリケーションを作成します。
Vertex AI Pipelines ジョブテンプレートを作成して、次の操作を行います。
- NFS 共有のデータに対してトレーニングジョブを作成して実行します。
- トレーニング済みモデルをインポートして Vertex AI Model Registry にアップロードします。
- オンライン予測用の Vertex AI エンドポイントを作成します。
- エンドポイントにモデルをデプロイします。
パイプラインテンプレートを Artifact Registry リポジトリにアップロードします。
Vertex AI Pipelines REST API を使用して、オンプレミスデータサービスホスト（on-prem-dataservice-host）からパイプラインの実行をトリガーします。

費用

このドキュメントでは、課金対象である次の Google Cloudコンポーネントを使用します。

料金計算ツールを使うと、予想使用量に基づいて費用の見積もりを生成できます。

新規の Google Cloud ユーザーは無料トライアルをご利用いただける場合があります。

このドキュメントに記載されているタスクの完了後、作成したリソースを削除すると、それ以上の請求は発生しません。詳細については、クリーンアップをご覧ください。

始める前に

In the Google Cloud console, go to the project selector page.

Go to project selector
Select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
- Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
Verify that billing is enabled for your Google Cloud project.
このチュートリアルで説明するコマンドを実行するために、Cloud Shell を開きます。Cloud Shell は Google Cloud のインタラクティブなシェル環境であり、ウェブブラウザからプロジェクトやリソースを管理できます。
Cloud Shell で現在のプロジェクトを Google Cloud プロジェクト ID に設定してから、同じプロジェクト ID を projectid シェル変数に保存します。
```
  projectid="PROJECT_ID"
  gcloud config set project ${projectid}
```
PROJECT_ID は、実際のプロジェクト ID に置き換えます。プロジェクト ID は Google Cloud コンソールでも確認できます。詳細については、プロジェクト ID を確認するをご覧ください。
プロジェクトオーナーでない場合は、プロジェクト IAM 管理者（roles/resourcemanager.projectIamAdmin）のロールを付与するようプロジェクトオーナーに依頼してください。このロールは、次のステップで IAM ロールを付与するために必要です。
Make sure that you have the following role or roles on the project: roles/artifactregistry.admin, roles/artifactregistry.repoAdmin, roles/compute.instanceAdmin.v1, roles/compute.networkAdmin, roles/compute.securityAdmin, roles/dns.admin, roles/file.editor, roles/logging.viewer, roles/logging.admin, roles/notebooks.admin, roles/iam.serviceAccountAdmin, roles/iam.serviceAccountUser, roles/servicedirectory.editor, roles/servicemanagement.quotaAdmin, roles/serviceusage.serviceUsageAdmin, roles/storage.admin, roles/storage.objectAdmin, roles/aiplatform.admin, roles/aiplatform.user, roles/aiplatform.viewer, roles/iap.admin, roles/iap.tunnelResourceAccessor, roles/resourcemanager.projectIamAdmin
Check for the roles
1. In the Google Cloud console, go to the IAM page.
  Go to IAM
2. Select the project.
3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.
4. For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.
Grant the roles
1. In the Google Cloud console, go to the IAM page.
  [IAM] に移動
2. プロジェクトを選択します。
3. [ アクセスを許可] をクリックします。
4. [新しいプリンシパル] フィールドに、ユーザー ID を入力します。これは通常、Google アカウントのメールアドレスです。
5. [ロールを選択] リストでロールを選択します。
6. 追加のロールを付与するには、 [別のロールを追加] をクリックして各ロールを追加します。
7. [保存] をクリックします。
Enable the DNS, Artifact Registry, IAM, Compute Engine, Cloud Logging, Network Connectivity, Notebooks, Cloud Filestore, Service Networking, Service Usage, and Vertex AI APIs.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the APIs

VPC ネットワークを作成する

このセクションでは、2 つの VPC ネットワークを作成します。1 つは Vertex AI Pipelines 用に Google API にアクセスするためのもので、もう 1 つはオンプレミスネットワークをシミュレートするためのものです。2 つの VPC ネットワークに、それぞれ Cloud Router と Cloud NAT ゲートウェイを作成します。Cloud NAT ゲートウェイは、外部 IP アドレスを持たない Compute Engine 仮想マシン（VM）インスタンスの送信接続を提供します。

Cloud Shell で、次のコマンドを実行します。ここで、PROJECT_ID はプロジェクト ID に置き換えます。
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

vertex-networking-vpc VPC ネットワークを作成します。

gcloud compute networks create vertex-networking-vpc \
    --subnet-mode custom

vertex-networking-vpc ネットワークで、プライマリ IPv4 範囲が 10.0.0.0/24 のサブネットを pipeline-networking-subnet1 という名前で作成します。

gcloud compute networks subnets create pipeline-networking-subnet1 \
    --range=10.0.0.0/24 \
    --network=vertex-networking-vpc \
    --region=us-central1 \
    --enable-private-ip-google-access

オンプレミスネットワーク（onprem-dataservice-vpc）をシミュレートするための VPC ネットワークを作成します。
```
gcloud compute networks create onprem-dataservice-vpc \
    --subnet-mode custom
```

onprem-dataservice-vpc ネットワークで、プライマリ IPv4 範囲が 172.16.10.0/24 のサブネットを onprem-dataservice-vpc-subnet1 という名前で作成します。

gcloud compute networks subnets create onprem-dataservice-vpc-subnet1 \
    --network onprem-dataservice-vpc \
    --range 172.16.10.0/24 \
    --region us-central1 \
    --enable-private-ip-google-access

VPC ネットワークが正しく構成されていることを確認する

Google Cloud コンソールで、[VPC ネットワーク] ページの [現在のプロジェクトのネットワーク] タブに移動します。

[VPC ネットワーク] に移動
VPC ネットワークのリストで、2 つのネットワーク（vertex-networking-vpc と onprem-dataservice-vpc）が作成されていることを確認します。
[現在のプロジェクトのサブネット] タブをクリックします。
VPC サブネットのリストで、pipeline-networking-subnet1 サブネットと onprem-dataservice-vpc-subnet1 サブネットが作成されていることを確認します。

ハイブリッド接続の構成

このセクションでは、相互に接続する 2 つの HA VPN ゲートウェイを作成します。1 つは vertex-networking-vpc VPC ネットワークにあります。もう一つは onprem-dataservice-vpc VPC ネットワークにあります。各ゲートウェイには、Cloud Router と VPN トンネルのペアが含まれます。

HA VPN ゲートウェイを作成する

Cloud Shell で、vertex-networking-vpc VPC ネットワークに HA VPN ゲートウェイを作成します。

gcloud compute vpn-gateways create vertex-networking-vpn-gw1 \
    --network vertex-networking-vpc \
    --region us-central1

onprem-dataservice-vpc VPC ネットワークに HA VPN ゲートウェイを作成します。

gcloud compute vpn-gateways create onprem-vpn-gw1 \
    --network onprem-dataservice-vpc \
    --region us-central1

Google Cloud コンソールで、[VPN] ページの [Cloud VPN ゲートウェイ] タブに移動します。

[VPN] に移動
2 つのゲートウェイ（vertex-networking-vpn-gw1 と onprem-vpn-gw1）が作成され、それぞれに 2 つのインターフェース IP アドレスがあることを確認します。

Cloud Router と Cloud NAT ゲートウェイを作成する

2 つの VPC ネットワークに、Cloud NAT で使用する Cloud Router と HA VPN の BGP セッションを管理する Cloud Router を 1 つずつ作成します。

Cloud Shell で、vertex-networking-vpc VPC ネットワークに、VPN に使用する Cloud Router を作成します。

gcloud compute routers create vertex-networking-vpc-router1 \
    --region us-central1 \
    --network vertex-networking-vpc \
    --asn 65001

onprem-dataservice-vpc VPC ネットワークに、VPN に使用する Cloud Router を作成します。

gcloud compute routers create onprem-dataservice-vpc-router1 \
    --region us-central1 \
    --network onprem-dataservice-vpc \
    --asn 65002

vertex-networking-vpc VPC ネットワークに、Cloud NAT に使用する Cloud Router を作成します。

gcloud compute routers create cloud-router-us-central1-vertex-nat \
    --network vertex-networking-vpc \
    --region us-central1

Cloud Router で Cloud NAT ゲートウェイを構成します。

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

onprem-dataservice-vpc VPC ネットワークに、Cloud NAT に使用する Cloud Router を作成します。

gcloud compute routers create cloud-router-us-central1-onprem-nat \
    --network onprem-dataservice-vpc \
    --region us-central1

Cloud Router で Cloud NAT ゲートウェイを構成します。

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

Google Cloud コンソールで、[Cloud Router] ページに移動します。

[Cloud Router] に移動
[Cloud Router] リストで、次のルーターが作成されていることを確認します。
- cloud-router-us-central1-onprem-nat
- cloud-router-us-central1-vertex-nat
- onprem-dataservice-vpc-router1
- vertex-networking-vpc-router1
新しい値を表示するには、 Google Cloud コンソールのブラウザタブの更新が必要となる場合があります。
[Cloud Router] リストで cloud-router-us-central1-vertex-nat をクリックします。
[ルーターの詳細] ページで、cloud-nat-us-central1 Cloud NAT ゲートウェイが作成されていることを確認します。
戻る矢印をクリックして、[Cloud Router] ページに戻ります。
[Cloud Router] リストで cloud-router-us-central1-onprem-nat をクリックします。
[ルーターの詳細] ページで、cloud-nat-us-central1-on-prem Cloud NAT ゲートウェイが作成されていることを確認します。

VPN トンネルを作成する

Cloud Shell で、vertex-networking-vpc ネットワークに VPN トンネル（vertex-networking-vpc-tunnel0）を作成します。

gcloud compute vpn-tunnels create vertex-networking-vpc-tunnel0 \
    --peer-gcp-gateway onprem-vpn-gw1 \
    --region us-central1 \
    --ike-version 2 \
    --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
    --router vertex-networking-vpc-router1 \
    --vpn-gateway vertex-networking-vpn-gw1 \
    --interface 0

vertex-networking-vpc ネットワークに、vertex-networking-vpc-tunnel1 という VPN トンネルを作成します。

gcloud compute vpn-tunnels create vertex-networking-vpc-tunnel1 \
    --peer-gcp-gateway onprem-vpn-gw1 \
    --region us-central1 \
    --ike-version 2 \
    --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
    --router vertex-networking-vpc-router1 \
    --vpn-gateway vertex-networking-vpn-gw1 \
    --interface 1

onprem-dataservice-vpc ネットワークに、onprem-dataservice-vpc-tunnel0 という VPN トンネルを作成します。

gcloud compute vpn-tunnels create onprem-dataservice-vpc-tunnel0 \
    --peer-gcp-gateway vertex-networking-vpn-gw1 \
    --region us-central1\
    --ike-version 2 \
    --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
    --router onprem-dataservice-vpc-router1 \
    --vpn-gateway onprem-vpn-gw1 \
    --interface 0

onprem-dataservice-vpc ネットワークに、onprem-dataservice-vpc-tunnel1 という VPN トンネルを作成します。

gcloud compute vpn-tunnels create onprem-dataservice-vpc-tunnel1 \
    --peer-gcp-gateway vertex-networking-vpn-gw1 \
    --region us-central1\
    --ike-version 2 \
    --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
    --router onprem-dataservice-vpc-router1 \
    --vpn-gateway onprem-vpn-gw1 \
    --interface 1

Google Cloud コンソールで、[VPN] ページに移動します。

[VPN] に移動
VPN トンネルのリストで、4 つの VPN トンネルが作成されていることを確認します。

BGP セッションを確立する

Cloud Router は、Border Gateway Protocol（BGP）を使用して、VPC ネットワーク（この場合は vertex-networking-vpc）とオンプレミスネットワーク（onprem-dataservice-vpc で表される）間のルートを交換します。Cloud Router で、オンプレミスルーターのインターフェースと BGP ピアを構成します。インターフェースと BGP ピア構成は、BGP セッションを形成します。このセクションでは、vertex-networking-vpc に 2 つ、onprem-dataservice-vpc に 2 つの BGP セッションを作成します。

ルーター間のインターフェースと BGP ピアを構成すると、ルートの交換が自動的に開始されます。

`vertex-networking-vpc` の BGP セッションを確立する

Cloud Shell で、vertex-networking-vpc ネットワークに vertex-networking-vpc-tunnel0 用の BGP インターフェースを作成します。

gcloud compute routers add-interface vertex-networking-vpc-router1 \
    --interface-name if-tunnel0-to-onprem \
    --ip-address 169.254.0.1 \
    --mask-length 30 \
    --vpn-tunnel vertex-networking-vpc-tunnel0 \
    --region us-central1

vertex-networking-vpc ネットワークに、bgp-onprem-tunnel0 の BGP ピアを作成します。

gcloud compute routers add-bgp-peer vertex-networking-vpc-router1 \
    --peer-name bgp-onprem-tunnel0 \
    --interface if-tunnel0-to-onprem \
    --peer-ip-address 169.254.0.2 \
    --peer-asn 65002 \
    --region us-central1

vertex-networking-vpc ネットワークに、vertex-networking-vpc-tunnel1 の BGP インターフェースを作成します。

gcloud compute routers add-interface vertex-networking-vpc-router1 \
    --interface-name if-tunnel1-to-onprem \
    --ip-address 169.254.1.1 \
    --mask-length 30 \
    --vpn-tunnel vertex-networking-vpc-tunnel1 \
    --region us-central1

vertex-networking-vpc ネットワークに、bgp-onprem-tunnel1 の BGP ピアを作成します。

gcloud compute routers add-bgp-peer vertex-networking-vpc-router1 \
    --peer-name bgp-onprem-tunnel1 \
    --interface if-tunnel1-to-onprem \
    --peer-ip-address 169.254.1.2 \
    --peer-asn 65002 \
    --region us-central1

`onprem-dataservice-vpc` の BGP セッションを確立する

onprem-dataservice-vpc ネットワークに、onprem-dataservice-vpc-tunnel0 の BGP インターフェースを作成します。

gcloud compute routers add-interface onprem-dataservice-vpc-router1 \
    --interface-name if-tunnel0-to-vertex-networking-vpc \
    --ip-address 169.254.0.2 \
    --mask-length 30 \
    --vpn-tunnel onprem-dataservice-vpc-tunnel0 \
    --region us-central1

onprem-dataservice-vpc ネットワークに、bgp-vertex-networking-vpc-tunnel0 の BGP ピアを作成します。

gcloud compute routers add-bgp-peer onprem-dataservice-vpc-router1 \
    --peer-name bgp-vertex-networking-vpc-tunnel0 \
    --interface if-tunnel0-to-vertex-networking-vpc \
    --peer-ip-address 169.254.0.1 \
    --peer-asn 65001 \
    --region us-central1

onprem-dataservice-vpc ネットワークに、onprem-dataservice-vpc-tunnel1 の BGP インターフェースを作成します。

gcloud compute routers add-interface onprem-dataservice-vpc-router1  \
    --interface-name if-tunnel1-to-vertex-networking-vpc \
    --ip-address 169.254.1.2 \
    --mask-length 30 \
    --vpn-tunnel onprem-dataservice-vpc-tunnel1 \
    --region us-central1

onprem-dataservice-vpc ネットワークに、bgp-vertex-networking-vpc-tunnel1 の BGP ピアを作成します。

gcloud compute routers add-bgp-peer onprem-dataservice-vpc-router1 \
    --peer-name bgp-vertex-networking-vpc-tunnel1 \
    --interface if-tunnel1-to-vertex-networking-vpc \
    --peer-ip-address 169.254.1.1 \
    --peer-asn 65001 \
    --region us-central1

BGP セッションの作成を確認する

Google Cloud コンソールで、[VPN] ページに移動します。

[VPN] に移動
VPN トンネルのリストで、各トンネルの [BGP セッションのステータス] 列の値が「BGP セッションを構成」から「BGP が確立されました」に変更されていることを確認します。新しい値を表示するには、 Google Cloud コンソールのブラウザタブの更新が必要となる場合があります。

`onprem-dataservice-vpc` の学習されたルートを検証する

Google Cloud コンソールで、[VPC ネットワーク] ページに移動します。

[VPC ネットワーク] に移動
VPC ネットワークのリストで onprem-dataservice-vpc をクリックします。
[ルート] タブをクリックします。
[リージョン] リストで [us-central1（アイオワ）] を選択し、[表示] をクリックします。
[送信先 IP 範囲] 列で、pipeline-networking-subnet1 サブネットの IP 範囲（10.0.0.0/24）が 2 回表示されていることを確認します。

両方のエントリを表示するには、 Google Cloud コンソールのブラウザタブを更新する必要があります。

`vertex-networking-vpc` の学習されたルートを検証する

戻る矢印をクリックして、[VPC ネットワーク] ページに戻ります。
VPC ネットワークのリストで vertex-networking-vpc をクリックします。
[ルート] タブをクリックします。
[リージョン] リストで [us-central1（アイオワ）] を選択し、[表示] をクリックします。
[送信先 IP 範囲] 列で、onprem-dataservice-vpc-subnet1 サブネットの IP 範囲（172.16.10.0/24）が 2 回表示されていることを確認します。

Google API 用の Private Service Connect エンドポイントを作成する

このセクションでは、オンプレミスネットワークから Vertex AI Pipelines REST API にアクセスするために使用する Google API 用に、Private Service Connect エンドポイントを作成します。

Cloud Shell で、Google API へのアクセスに使用するコンシューマーエンドポイントの IP アドレスを予約します。

gcloud compute addresses create psc-googleapi-ip \
    --global \
    --purpose=PRIVATE_SERVICE_CONNECT \
    --addresses=192.168.0.1 \
    --network=vertex-networking-vpc

エンドポイントを Google API およびサービスに接続する転送ルールを作成します。

gcloud compute forwarding-rules create pscvertex \
   --global \
   --network=vertex-networking-vpc \
   --address=psc-googleapi-ip \
   --target-google-apis-bundle=all-apis

`vertex-networking-vpc` のカスタムルートアドバタイズを作成する

このセクションでは、vertex-networking-vpc-router1（vertex-networking-vpc の Cloud Router）用にカスタムルートアドバタイズを作成して、PSC エンドポイントの IP アドレスを onprem-dataservice-vpc VPC ネットワークにアドバタイズします。

Google Cloud コンソールで、[Cloud Router] ページに移動します。

[Cloud Router] に移動
[Cloud Router] リストで vertex-networking-vpc-router1 をクリックします。
[ルーターの詳細] ページで、[ 編集] をクリックします。
[アドバタイズされたルート] セクションの [ルート] で、[カスタムルートの作成] を選択します。
[Cloud Router に表示されるすべてのサブネットにアドバタイズする] チェックボックスをオンにして、Cloud Router に利用可能なサブネットのアドバタイジングを継続します。このオプションを有効にすると、デフォルトのアドバタイズモードでの Cloud Router の動作が模倣されます。
[カスタムルートの追加] をクリックします。
[ソース] で [カスタム IP 範囲] を選択します。
[IP アドレス範囲] には、次の IP アドレスを入力します。
```
192.168.0.1
```

[説明] には、次のテキストを入力します。

Custom route to advertise Private Service Connect endpoint IP address

[完了] をクリックし、[保存] をクリックします。

`onprem-dataservice-vpc` がアドバタイズされたルートを学習したことを確認する

Google Cloud コンソールで、[ルート] ページに移動します。

[ルート] に移動
[適用されているルート] タブで、次の操作を行います。
1. [ネットワーク] には [onprem-dataservice-vpc] を選択します。
2. [リージョン] には us-central1 (Iowa) を選択します。
3. [表示] をクリックします。
4. ルートのリストで、名前が onprem-dataservice-vpc-router1-bgp-vertex-networking-vpc-tunnel0 で始まるエントリが 2 つ、onprem-dataservice-vpc-router1-bgp-vertex-networking-vpc-tunnel1 で始まるエントリが 2 つあることを確認します。
  
  これらのエントリがすぐに表示されない場合は、数分待ってから、 Google Cloud コンソールのブラウザタブを更新してください。
5. 2 つのエントリの [送信先 IP 範囲] が 192.168.0.1/32 で、2 つのエントリの [送信先 IP 範囲] が 10.0.0.0/24 であることを確認します。

`onprem-dataservice-vpc` に VM インスタンスを作成する

このセクションでは、オンプレミスデータサービスホストをシミュレートする VM インスタンスを作成します。Compute Engine と IAM のベストプラクティスに従って、この VM は Compute Engine のデフォルトのサービスアカウントではなく、ユーザー管理のサービスアカウントを使用します。

VM インスタンスのユーザー管理サービスアカウントを作成する

Cloud Shell で、次のコマンドを実行します。ここで、PROJECT_ID はプロジェクト ID に置き換えます。
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

onprem-user-managed-sa という名前のサービスアカウントを作成します。

gcloud iam service-accounts create onprem-user-managed-sa \
    --display-name="onprem-user-managed-sa"

サービスアカウントに Vertex AI ユーザー（roles/aiplatform.user）ロールを割り当てます。

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

Vertex AI 閲覧者（roles/aiplatform.viewer）ロールを割り当てます。

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

Filestore 編集者（roles/file.editor）ロールを割り当てます。

gcloud projects add-iam-policy-binding $projectid \
    --member="serviceAccount:onprem-user-managed-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/file.editor"

サービスアカウント管理者（roles/iam.serviceAccountAdmin）ロールを割り当てます。

gcloud projects add-iam-policy-binding $projectid \
    --member="serviceAccount:onprem-user-managed-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/iam.serviceAccountAdmin"

サービスアカウントユーザー（roles/iam.serviceAccountUser）ロールを割り当てます。

gcloud projects add-iam-policy-binding $projectid \
    --member="serviceAccount:onprem-user-managed-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/iam.serviceAccountUser"

Artifact Registry 読み取り（roles/artifactregistry.reader）ロールを割り当てます。

gcloud projects add-iam-policy-binding $projectid \
    --member="serviceAccount:onprem-user-managed-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/artifactregistry.reader"

Storage オブジェクト管理者（roles/storage.objectAdmin）ロールを割り当てます。

gcloud projects add-iam-policy-binding $projectid \
    --member="serviceAccount:onprem-user-managed-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/storage.objectAdmin"

Logging 管理者（roles/logging.admin）ロールを割り当てます。

gcloud projects add-iam-policy-binding $projectid \
    --member="serviceAccount:onprem-user-managed-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/logging.admin"

`on-prem-dataservice-host` VM インスタンスを作成する

作成する VM インスタンスには外部 IP アドレスがなく、インターネット経由の直接アクセスは許可されません。VM への管理者権限を有効にするには、Identity-Aware Proxy（IAP）TCP 転送を使用します。

Cloud Shell で、on-prem-dataservice-host VM インスタンスを作成します。

gcloud compute instances create on-prem-dataservice-host \
    --zone=us-central1-a \
    --image-family=debian-11 \
    --image-project=debian-cloud \
    --subnet=onprem-dataservice-vpc-subnet1 \
    --scopes=https://www.googleapis.com/auth/cloud-platform \
    --no-address \
    --shielded-secure-boot \
    --service-account=onprem-user-managed-sa@$projectid.iam.gserviceaccount.com \
    --metadata startup-script="#! /bin/bash
sudo apt-get update
sudo apt-get install tcpdump dnsutils -y"

IAP が VM インスタンスに接続できるようにするファイアウォールルールを作成します。

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

PSC エンドポイントを指すように `/etc/hosts` ファイルを更新する

このセクションでは、/etc/hosts ファイルに、パブリックサービスエンドポイント（us-central1-aiplatform.googleapis.com）に送信されたリクエストを PSC エンドポイント（192.168.0.1）にリダイレクトする行を追加します。

Cloud Shell で、IAP を使用して on-prem-dataservice-host VM インスタンスにログインします。
```
gcloud compute ssh on-prem-dataservice-host \
  --zone=us-central1-a \
  --tunnel-through-iap
```
on-prem-dataservice-host VM インスタンスで、テキストエディタ（vim や nano など）を使用して /etc/hosts ファイルを開きます。次に例を示します。
```
sudo vim /etc/hosts
```

次の行をファイルに追加します。

192.168.0.1 us-central1-aiplatform.googleapis.com

この行では、PSC エンドポイントの IP アドレス（192.168.0.1）を Vertex AI Google API の完全修飾ドメイン名（us-central1-aiplatform.googleapis.com）に割り当てています。

編集されたファイルは、次のようになります。

127.0.0.1       localhost
::1             localhost ip6-localhost ip6-loopback
ff02::1         ip6-allnodes
ff02::2         ip6-allrouters

192.168.0.1 us-central1-aiplatform.googleapis.com  # Added by you
172.16.10.6 on-prem-dataservice-host.us-central1-a.c.PROJECT_ID.internal on-prem-dataservice-host  # Added by Google
169.254.169.254 metadata.google.internal  # Added by Google

次のようにファイルを保存します。
- vim を使用している場合は、Esc キーを押してから、「:wq」と入力してファイルを保存し、終了します。
- nano を使用している場合は、「Control+O」と入力して Enter を押してファイルを保存し、「Control+X」と入力して終了します。
次のように Vertex AI API エンドポイントに対して ping を実行します。
```
ping us-central1-aiplatform.googleapis.com
```
ping コマンドでは、次の出力が返されます。192.168.0.1 は、PSC エンドポイントの IP アドレスです。
```
PING us-central1-aiplatform.googleapis.com (192.168.0.1) 56(84) bytes of data.
```
「Control+C」と入力して ping を終了します。
exit と入力して on-prem-dataservice-host VM インスタンスを終了し、Cloud Shell プロンプトに戻ります。

Filestore インスタンスのネットワークを構成する

このセクションでは、Filestore インスタンスを作成してネットワークファイルシステム（NFS）共有としてマウントする準備として、VPC ネットワークのプライベートサービスアクセスを有効にします。このセクションと次のセクションで行う作業の詳細については、カスタムトレーニング用の NFS 共有をマウントすると VPC ネットワークピアリングを設定するをご覧ください。

VPC ネットワークでプライベートサービスアクセスを有効にする

このセクションでは、サービスネットワーキング接続を作成し、これを使用して、VPC ネットワークピアリングを介して onprem-dataservice-vpc VPC ネットワークへのプライベートサービスアクセスを有効にします。

Cloud Shell で、gcloud compute addresses create を使用して予約済みの IP アドレス範囲を設定します。

gcloud compute addresses create filestore-subnet \
   --global \
   --purpose=VPC_PEERING \
   --addresses=10.243.208.0 \
   --prefix-length=24 \
   --description="filestore subnet" \
   --network=onprem-dataservice-vpc

gcloud services vpc-peerings connect を使用して、onprem-dataservice-vpc VPC ネットワークと Google のサービスネットワーキングの間にピアリング接続を確立します。
```
gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges=filestore-subnet \
    --network=onprem-dataservice-vpc
```

VPC ネットワークピアリングを更新して、カスタム学習ルートのインポートとエクスポートを有効にします。

gcloud compute networks peerings update servicenetworking-googleapis-com \
    --network=onprem-dataservice-vpc \
    --import-custom-routes \
    --export-custom-routes

Google Cloud コンソールで [VPC ネットワークピアリング] ページに移動します。

[VPC ネットワークピアリング] に移動
VPC ピアリングのリストで、servicenetworking.googleapis.com と onprem-dataservice-vpc VPC ネットワーク間のピアリングのエントリがあることを確認します。

`filestore-subnet` のカスタムルートアドバタイズを作成する

Google Cloud コンソールで、[Cloud Router] ページに移動します。

[Cloud Router] に移動
[Cloud Router] リストで onprem-dataservice-vpc-router1 をクリックします。
[ルーターの詳細] ページで、[ 編集] をクリックします。
[アドバタイズされたルート] セクションの [ルート] で、[カスタムルートの作成] を選択します。
[Cloud Router に表示されるすべてのサブネットにアドバタイズする] チェックボックスをオンにして、Cloud Router に利用可能なサブネットのアドバタイジングを継続します。このオプションを有効にすると、デフォルトのアドバタイズモードでの Cloud Router の動作が模倣されます。
[カスタムルートの追加] をクリックします。
[ソース] で [カスタム IP 範囲] を選択します。
[IP アドレス範囲] には、次の IP アドレス範囲を入力します。
```
10.243.208.0/24
```
[説明] には、次のテキストを入力します。
```
Filestore reserved IP address range
```
[完了] をクリックし、[保存] をクリックします。

`onprem-dataservice-vpc` ネットワークに Filestore インスタンスを作成する

VPC ネットワークでプライベートサービスアクセスを有効にしたら、Filestore インスタンスを作成し、カスタムトレーニングジョブ用に NFS 共有としてインスタンスをマウントします。これにより、トレーニングジョブがローカルに存在するかのようにリモートファイルにアクセスできるようになり、高スループットと低レイテンシが実現します。

Filestore インスタンスを作成する

Google Cloud コンソールで、[Filestore インスタンス] ページに移動します。

[Filestore インスタンス] に移動
[インスタンスを作成] をクリックし、次のようにインスタンスを構成します。
- [インスタンス ID] を次のように設定します。
```
image-data-instance
```
- [インスタンスのタイプ] を [基本] に設定します。
- [ストレージの種類] を [HDD] に設定します。
- [容量の割り当て] を 1 TiB に設定します。
- [リージョン] を us-central1、[ゾーン] を us-central1-c に設定します。
- [VPC ネットワーク] を onprem-dataservice-vpc に設定します。
- [割り振られている IP 範囲] を [既存の割り振り済みの IP 範囲を使用する] に設定し、filestore-subnet を選択します。
- [ファイル共有の名前] を次のように設定します。
```
vol1
```
- [アクセス制御] を [VPC ネットワーク上のすべてのクライアントにアクセス権を付与する] に設定します。
[作成] をクリックします。
新しい Filestore インスタンスの IP アドレスをメモしておきます。新しいインスタンスを表示するには、 Google Cloud コンソールのブラウザタブの更新が必要となる場合があります。

Filestore のファイル共有をマウントする

Cloud Shell で、次のコマンドを実行します。ここで、PROJECT_ID はプロジェクト ID に置き換えます。
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

on-prem-dataservice-host VM インスタンスにログインします。

gcloud compute ssh on-prem-dataservice-host \
    --zone=us-central1-a \
    --tunnel-through-iap

VM インスタンスに NFS パッケージをインストールします。
```
sudo apt-get update -y
sudo apt-get -y install nfs-common
```
Filestore ファイル共有のマウントディレクトリを作成します。
```
sudo mkdir -p /mnt/nfs
```
注: /mnt/ 内のマウントポイントのフォルダ名が nfs であることを確認してください。これは、NFS ファイル共有がカスタムトレーニングジョブ内の /mnt/nfs/ の下にマウントされているためです。
ファイル共有をマウントします。FILESTORE_INSTANCE_IP は Filestore インスタンスの IP アドレスに置き換えます。
```
sudo mount FILESTORE_INSTANCE_IP:/vol1 /mnt/nfs
```
接続がタイムアウトした場合は、Filestore インスタンスの正しい IP アドレスを指定しているかを確認します。

次のコマンドを実行して、NFS マウントが正常に完了したことを確認します。

df -h

結果に /mnt/nfs ファイル共有が表示されていることを確認します。

Filesystem           Size  Used Avail Use% Mounted on
udev                 1.8G     0  1.8G   0% /dev
tmpfs                368M  396K  368M   1% /run
/dev/sda1            9.7G  1.9G  7.3G  21% /
tmpfs                1.8G     0  1.8G   0% /dev/shm
tmpfs                5.0M     0  5.0M   0% /run/lock
/dev/sda15           124M   11M  114M   9% /boot/efi
tmpfs                368M     0  368M   0% /run/user
10.243.208.2:/vol1  1007G     0  956G   0% /mnt/nfs

権限を変更し、ファイル共有にアクセスできるようにします。
```
sudo chmod go+rw /mnt/nfs
```
注: 本番環境では、よりきめ細かいアクセス許可を設定することをおすすめします。詳細については、ファイル共有のアクセス権限を構成するをご覧ください。

データセットをファイル共有にダウンロードする

on-prem-dataservice-host VM インスタンスで、データセットをファイル共有にダウンロードします。
```
gcloud storage cp gs://cloud-samples-data/vertex-ai/dataset-management/datasets/fungi_dataset /mnt/nfs/ --recursive
```
ダウンロードには数分かかります。
次のコマンドを実行して、データセットが正常にコピーされたことを確認します。
```
sudo du -sh /mnt/nfs
```
想定される出力は次のとおりです。
```
104M    /mnt/nfs
```
exit と入力して on-prem-dataservice-host VM インスタンスを終了し、Cloud Shell プロンプトに戻ります。

パイプラインのステージングバケットを作成する

Vertex AI Pipelines は、Cloud Storage を使用してパイプライン実行のアーティファクトを保存します。パイプラインを実行する前に、パイプライン実行をステージングするための Cloud Storage バケットを作成する必要があります。

Cloud Shell で、Cloud Storage バケットを作成します。

gcloud storage buckets create gs://pipelines-staging-bucket-$projectid --location=us-central1

Vertex AI Workbench のユーザー管理サービスアカウントを作成する

Cloud Shell で、サービスアカウントを作成します。

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

サービスアカウントに Vertex AI ユーザー（roles/aiplatform.user）ロールを割り当てます。

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

Artifact Registry 管理者（artifactregistry.admin）ロールを割り当てます。

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

ストレージ管理者（storage.admin）ロールを割り当てます。

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

Python トレーニングアプリケーションを作成する

このセクションでは、Vertex AI Workbench インスタンスを作成し、それを使用して Python カスタムトレーニングアプリケーションパッケージを作成します。

Vertex AI Workbench インスタンスを作成する

Google Cloud コンソールで、[Vertex AI Workbench] ページの [インスタンス] タブに移動します。

[Vertex AI Workbench] に移動
[新規作成] をクリックし、[詳細オプション] をクリックします。

[新しいインスタンス] ページが開きます。
[新しいインスタンス] ページの [詳細] セクションで、新しいインスタンスについて次の情報を入力し、[続行] をクリックします。
- 名前: PROJECT_ID をプロジェクト ID に置き換えて、次のように入力します。
```
pipeline-tutorial-PROJECT_ID
```
- リージョン: [us-central1] を選択します。
- ゾーン: 「us-central1-a」を選択します。
- [Dataproc Serverless インタラクティブセッションを有効にする] チェックボックスをオフにします。
[環境] セクションで、[続行] をクリックします。
[マシンタイプ] セクションで、以下を指定して [続行] をクリックします。
- マシンタイプ: [N1] を選択し、[マシンタイプ] メニューから n1-standard-4 を選択します。
- Shielded VM: 次のチェックボックスをオンにします。
  - セキュアブート
  - 仮想トラステッドプラットフォームモジュール（vTPM）
  - 整合性モニタリング
[ディスク] セクションで Google-managed encryption key が選択されていることを確認して、[続行] をクリックします。
[ネットワーキング] セクションで次の設定を行い、[続行] をクリックします。
- ネットワーキング: [このプロジェクトのネットワーク] を選択し、次の操作を行います。
  1. [ネットワーク] フィールドで、[vertex-networking-vpc] を選択します。
  2. [サブネットワーク] フィールドで、[pipeline-networking-subnet1] を選択します。
  3. [外部 IP アドレスを割り当て] チェックボックスをオフにします。外部 IP アドレスを割り当てると、インスタンスはインターネットまたは他の VPC ネットワークからの未承諾通信を受信できなくなります。
  4. [プロキシアクセスを許可] チェックボックスをオンにします。
[IAM とセキュリティ] セクションで、以下を指定して、[続行] をクリックします。
- IAM とセキュリティ: インスタンスの JupyterLab インターフェースへのアクセス権を単一のユーザーに付与するには、次の操作を行います。
  1. [Service account] を選択します。
  2. [Compute Engine のデフォルトのサービスアカウントを使用する] チェックボックスをオフにします。Compute Engine のデフォルトのサービスアカウント（つまり指定した単一のユーザー）には、プロジェクトの編集者ロール（roles/editor）が付与される可能性があるため、このステップは重要です。
  3. [サービスアカウントのメールアドレス] フィールドに、次のように入力します。PROJECT_ID は、プロジェクト ID に置き換えます。
```
workbench-sa@PROJECT_ID.iam.gserviceaccount.com
```
    （これは、先ほど作成したカスタムサービスアカウントのメールアドレスです）このサービスアカウントの権限は制限されています。
    
    アクセス権の付与の詳細については、Vertex AI Workbench インスタンスの JupyterLab インターフェースへのアクセスを管理するをご覧ください。
- セキュリティオプション: 次のチェックボックスをオフにします。
  - インスタンスに対するルートアクセス
  次のチェックボックスをオンにします。
  - nbconvert: nbconvert を使用すると、ユーザーはノートブックファイルを別の形式（HTML、PDF、LaTeX など）でエクスポートして、ダウンロードできます。この設定は、Google Cloud 生成 AI GitHub リポジトリの一部のノートブックで必要になります。
  以下のチェックボックスをオフにします。
  - ファイルのダウンロード
  本番環境以外の場合は、次のチェックボックスをオンにします。
  - ターミナルアクセス: JupyterLab ユーザーインターフェースからインスタンスへのターミナルアクセスが可能になります。
[システムの状態] セクションで [環境の自動アップグレード] のチェックをはずし、次の情報を入力します。
- [レポート] で、次のチェックボックスをオンにします。
  - システムの状態を報告
  - Cloud Monitoring にカスタム指標を報告する
  - Cloud Monitoring をインストールする
  - 必要な Google ドメインの DNS ステータスを報告する
[作成] をクリックし、Vertex AI Workbench インスタンスが作成されるまで数分待ちます。

Vertex AI Workbench インスタンスでトレーニングアプリケーションを実行する

Google Cloud コンソールで、[Vertex AI Workbench] ページの [インスタンス] タブに移動します。

Vertex AI Workbench に移動
Vertex AI Workbench インスタンス名（pipeline-tutorial-PROJECT_ID）の横にある [JupyterLab を開く] をクリックします（PROJECT_ID はプロジェクト ID です）。

JupyterLab で Vertex AI Workbench インスタンスが開きます。
[ファイル > 新規 > ターミナル] を選択します。
（Cloud Shell ではなく）JupyterLab ターミナルで、プロジェクトの環境変数を定義します。PROJECT_ID は、プロジェクト ID で置き換えてください。
```
projectid=PROJECT_ID
```
（引き続き JupyterLab ターミナルで）トレーニングアプリケーションの親ディレクトリを作成します。
```
mkdir fungi_training_package
mkdir fungi_training_package/trainer
```
[ File Browser] で、fungi_training_package フォルダをダブルクリックし、続いて trainer フォルダをダブルクリックします。
[ File Browser] で、空のファイルリスト（[Name] の見出しの下）を右クリックし、[New file] を選択します。
新しいファイルを右クリックして、[Rename file] を選択します。
ファイルの名前を untitled.txt から task.py に変更します。
task.py ファイルをダブルクリックして開きます。

次のコードを task.py にコピーします。

# Import the libraries
import tensorflow as tf
from tensorflow.python.client import device_lib
import argparse
import os
import sys
# add parser arguments
parser = argparse.ArgumentParser()
parser.add_argument('--data-dir', dest='dataset_dir', type=str, 
                 help='Dir to access dataset.')
parser.add_argument('--model-dir', dest='model_dir', default=os.getenv("AIP_MODEL_DIR"), type=str,
                 help='Dir to save the model.')
parser.add_argument('--epochs', dest='epochs', default=10, type=int,
                 help='Number of epochs.')
parser.add_argument('--batch-size', dest='batch_size', default=32, type=int,
                 help='Number of images per batch.')
parser.add_argument('--distribute', dest='distribute', default='single', type=str, 
                 help='distributed training strategy.')
args = parser.parse_args()
# print the tf version and config
print('Python Version = {}'.format(sys.version))
print('TensorFlow Version = {}'.format(tf.__version__))
print('TF_CONFIG = {}'.format(os.environ.get('TF_CONFIG', 'Not found')))
print('DEVICES', device_lib.list_local_devices())

# Single Machine, single compute device
if args.distribute == 'single':
    if tf.test.is_gpu_available():
        strategy = tf.distribute.OneDeviceStrategy(device="/gpu:0")
    else:
        strategy = tf.distribute.OneDeviceStrategy(device="/cpu:0")
# Single Machine, multiple compute device
elif args.distribute == 'mirror':
    strategy = tf.distribute.MirroredStrategy()
# Multiple Machine, multiple compute device
elif args.distribute == 'multi':
    strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy()

# Multi-worker configuration
print('num_replicas_in_sync = {}'.format(strategy.num_replicas_in_sync))

# Preparing dataset
BUFFER_SIZE = 1000
IMG_HEIGHT = 224
IMG_WIDTH = 224

def make_datasets_batched(dataset_path, global_batch_size):
    # Configure the training data generator
    train_data_dir = os.path.join(dataset_path,"train/")
    train_ds = tf.keras.utils.image_dataset_from_directory(
                         train_data_dir,
                         seed=36,
                         image_size=(IMG_HEIGHT, IMG_WIDTH),
                         batch_size=global_batch_size
               )
    # Configure the validation data generator
    val_data_dir = os.path.join(dataset_path,"valid/")
    val_ds = tf.keras.utils.image_dataset_from_directory(
                       val_data_dir,
                       seed=36,
                       image_size=(IMG_HEIGHT, IMG_WIDTH),
                       batch_size=global_batch_size
             )
    # get the number of classes in the data
    num_classes = len(train_ds.class_names)

    # Configure the dataset for performance
    AUTOTUNE = tf.data.AUTOTUNE
    train_ds = train_ds.cache().shuffle(BUFFER_SIZE).prefetch(buffer_size=AUTOTUNE)
    val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)
    return train_ds, val_ds, num_classes

# Build the Keras model
def build_and_compile_cnn_model(num_classes):
    # build a CNN model
    model = tf.keras.models.Sequential([
      tf.keras.layers.Rescaling(1./255, input_shape=(IMG_HEIGHT, IMG_WIDTH, 3)),
      tf.keras.layers.Conv2D(16, 3, padding='same', activation='relu'),
      tf.keras.layers.MaxPooling2D(),
      tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu'),
      tf.keras.layers.MaxPooling2D(),
      tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),
      tf.keras.layers.MaxPooling2D(),
      tf.keras.layers.Flatten(),
      tf.keras.layers.Dense(128, activation='relu'),
      tf.keras.layers.Dense(num_classes)
    ])
    # compile the CNN model
    model.compile(optimizer='adam',
               loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
               metrics=['accuracy'])
    return model

# Get the strategy data
NUM_WORKERS = strategy.num_replicas_in_sync
# Here the batch size scales up by number of workers
GLOBAL_BATCH_SIZE = args.batch_size * NUM_WORKERS

# Create dataset generator objects
train_ds, val_ds, num_classes = make_datasets_batched(args.dataset_dir, GLOBAL_BATCH_SIZE)
# Compile the model
with strategy.scope():
    # Creation of dataset, and model building/compiling need to be within
    # `strategy.scope()`.
    model = build_and_compile_cnn_model(num_classes)
# fit the model on the data
history = model.fit(train_ds, validation_data=val_ds, epochs=args.epochs)
# save the model to the output dir
model.save(args.model_dir)

[File] > [Save Python file] を選択します。
JupyterLab ターミナルで、各サブディレクトリに __init__.py ファイルを作成し、パッケージにします。
```
touch fungi_training_package/__init__.py
touch fungi_training_package/trainer/__init__.py
```
[ File Browser] で、fungi_training_package フォルダをダブルクリックします。
[File] > [New] > [Python file] を選択します。
新しいファイルを右クリックして、[Rename file] を選択します。
ファイルの名前を untitled.py から setup.py に変更します。
setup.py ファイルをダブルクリックして開きます。

次のコードを setup.py にコピーします。

from setuptools import find_packages
from setuptools import setup
setup(
   name='trainer',
   version='0.1',
   packages=find_packages(),
   include_package_data=True,
   description='Training application package for fungi-classification.'
)

[File] > [Save Python file] を選択します。
ターミナルで、fungi_training_package ディレクトリに移動します。
```
cd fungi_training_package
```
sdist コマンドを使用して、トレーニングアプリケーションのソースディストリビューションを作成します。
```
python setup.py sdist --formats=gztar
```
親ディレクトリに移動します。
```
cd ..
```
正しいディレクトリにいることを確認します。
```
pwd
```
出力は次のようになります。
```
/home/jupyter
```

Python パッケージをステージングバケットにコピーします。

gcloud storage cp fungi_training_package/dist/trainer-0.1.tar.gz gs://pipelines-staging-bucket-$projectid/training_package/

ステージングバケットにパッケージが含まれていることを確認します。

gcloud storage ls gs://pipelines-staging-bucket-$projectid/training_package

次のように出力されます。

gs://pipelines-staging-bucket-PROJECT_ID/training_package/trainer-0.1.tar.gz

Vertex AI Pipelines のサービスネットワーキング接続を作成する

このセクションでは、VPC ネットワークピアリングを介して vertex-networking-vpc VPC ネットワークに接続されたプロデューサーサービスを確立するために使用されるサービスネットワーキング接続を作成します。詳細については、VPC ネットワークピアリングをご覧ください。

Cloud Shell で、次のコマンドを実行します。ここで、PROJECT_ID はプロジェクト ID に置き換えます。
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

gcloud compute addresses create を使用して予約済み IP アドレス範囲を設定します。

gcloud compute addresses create vertex-pipeline-subnet \
    --global \
    --purpose=VPC_PEERING \
    --addresses=192.168.10.0 \
    --prefix-length=24 \
    --description="pipeline subnet" \
    --network=vertex-networking-vpc

gcloud services vpc-peerings connect を使用して、vertex-networking-vpc VPC ネットワークと Google のサービスネットワーキングの間にピアリング接続を確立します。
```
gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges=vertex-pipeline-subnet \
    --network=vertex-networking-vpc
```

VPC ピアリング接続を更新して、カスタム学習ルートのインポートとエクスポートを有効にします。

gcloud compute networks peerings update servicenetworking-googleapis-com \
    --network=vertex-networking-vpc \
    --import-custom-routes \
    --export-custom-routes

`pipeline-networking` Cloud Router からパイプラインサブネットをアドバタイズする

Google Cloud コンソールで、[Cloud Router] ページに移動します。

[Cloud Router] に移動
[Cloud Router] リストで vertex-networking-vpc-router1 をクリックします。
[ルーターの詳細] ページで、[ 編集] をクリックします。
[カスタムルートの追加] をクリックします。
[ソース] で [カスタム IP 範囲] を選択します。
[IP アドレス範囲] には、次の IP アドレス範囲を入力します。
```
192.168.10.0/24
```
[説明] には、次のテキストを入力します。
```
Vertex AI Pipelines reserved subnet
```
[完了] をクリックし、[保存] をクリックします。

パイプラインテンプレートを作成して Artifact Registry にアップロードする

このセクションでは、Kubeflow Pipelines（KFP）パイプラインテンプレートを作成してアップロードします。このテンプレートには、1 人または複数のユーザーが複数回再利用できるワークフロー定義が含まれています。

パイプラインを定義してコンパイルする

Jupyterlab の [ File Browser] で、最上位のフォルダをダブルクリックします。
[File] > [New] > [Notebook] の順に選択します。
[Select Kernel] メニューから Python 3 (ipykernel) を選択し、[Select] をクリックします。
新しいノートブックのセルで次のコマンドを実行して、pip の最新バージョンがあることを確認します。
```
!python -m pip install --upgrade pip
```
次のコマンドを実行して、Python パッケージインデックス（PyPI）から Google Cloud パイプラインコンポーネント SDK をインストールします。
```
!pip install --upgrade google-cloud-pipeline-components
```
インストールが完了したら、[Kernel] > [Restart Kernel] の順に選択してカーネルを再起動し、ライブラリをインポートできることを確認します。

新しいノートブックのセルで次のコードを実行して、パイプラインを定義します。

from kfp import dsl
# define the train-deploy pipeline
@dsl.pipeline(name="custom-image-classification-pipeline")
def custom_image_classification_pipeline(
 project: str,
 training_job_display_name: str,
 worker_pool_specs: list,
 base_output_dir: str,
 model_artifact_uri: str,
 prediction_container_uri: str,
 model_display_name: str,
 endpoint_display_name: str,
 network: str = '',
 location: str="us-central1",
 serving_machine_type: str="n1-standard-4",
 serving_min_replica_count: int=1,
 serving_max_replica_count: int=1
 ):
 from google_cloud_pipeline_components.types import artifact_types
 from google_cloud_pipeline_components.v1.custom_job import CustomTrainingJobOp
 from google_cloud_pipeline_components.v1.model import ModelUploadOp
 from google_cloud_pipeline_components.v1.endpoint import (EndpointCreateOp,
                                                           ModelDeployOp)
 from kfp.dsl import importer

 # Train the model task
 custom_job_task = CustomTrainingJobOp(
      project=project,
      display_name=training_job_display_name,
      worker_pool_specs=worker_pool_specs,
      base_output_directory=base_output_dir,
      location=location,
      network=network
      )

 # Import the model task
 import_unmanaged_model_task = importer(
      artifact_uri=model_artifact_uri,
      artifact_class=artifact_types.UnmanagedContainerModel,
      metadata={
         "containerSpec": {
            "imageUri": prediction_container_uri,
            },
         },
         ).after(custom_job_task)
 # Model upload task
 model_upload_op = ModelUploadOp(
      project=project,
      display_name=model_display_name,
      unmanaged_container_model=import_unmanaged_model_task.outputs["artifact"],
      )
 model_upload_op.after(import_unmanaged_model_task)
 # Create Endpoint task
 endpoint_create_op = EndpointCreateOp(
      project=project,
      display_name=endpoint_display_name,
      )
 # Deploy the model to the endpoint
 ModelDeployOp(
      endpoint=endpoint_create_op.outputs["endpoint"],
      model=model_upload_op.outputs["model"],
      dedicated_resources_machine_type=serving_machine_type,
      dedicated_resources_min_replica_count=serving_min_replica_count,
      dedicated_resources_max_replica_count=serving_max_replica_count,
      )

新しいノートブックのセルで次のコードを実行して、パイプライン定義をコンパイルします。
```
from kfp import compiler 
PIPELINE_FILE = "pipeline_config.yaml"
compiler.Compiler().compile(
    pipeline_func=custom_image_classification_pipeline,
    package_path=PIPELINE_FILE,
)
```
[ File Browser] で、pipeline_config.yaml という名前のファイルがファイルリストに表示されます。

Artifact Registry リポジトリを作成する

新しいノートブックのセルで次のコードを実行して、KFP タイプのアーティファクトリポジトリを作成します。
```
REPO_NAME="fungi-repo"
REGION="us-central1"
!gcloud artifacts repositories create $REPO_NAME --location=$REGION --repository-format=KFP
```

パイプラインテンプレートを Artifact Registry にアップロードする

このセクションでは、Kubeflow Pipelines SDK レジストリクライアントを構成し、コンパイルされたパイプラインテンプレートを JupyterLab ノートブックから Artifact Registry にアップロードします。

JupyterLab ノートブックで次のコードを実行してパイプラインテンプレートをアップロードします。ここで、PROJECT_ID はプロジェクト ID に置き換えます。

PROJECT_ID = "PROJECT_ID"
from kfp.registry import RegistryClient
host = f"https://{REGION}-kfp.pkg.dev/{PROJECT_ID}/{REPO_NAME}"
client = RegistryClient(host=host)
TEMPLATE_NAME, VERSION_NAME = client.upload_pipeline(
   file_name=PIPELINE_FILE,
   tags=["v1", "latest"],
   extra_headers={"description":"This is an example pipeline template."})

テンプレートがアップロードされたことを確認するため、 Google Cloud コンソールで Vertex AI Pipelines テンプレートに移動します。

[パイプライン] に移動
[リポジトリを選択] ペインを開くには、[リポジトリを選択] をクリックします。
リポジトリリストで、作成したリポジトリ（fungi-repo）をクリックし、[選択] をクリックします。
パイプライン（custom-image-classification-pipeline）がリストに表示されていることを確認します。

オンプレミスからパイプライン実行をトリガーする

パイプラインテンプレートとトレーニングパッケージの準備ができたので、このセクションでは、cURL を使用してオンプレミスアプリケーションからパイプラインの実行をトリガーします。

パイプラインパラメータを指定する

JupyterLab ノートブックで、次のコマンドを実行してパイプラインテンプレート名を確認します。
```
print (TEMPLATE_NAME)
```
返されるテンプレート名は次のとおりです。
```
custom-image-classification-pipeline
```
次のコマンドを実行して、パイプラインテンプレートのバージョンを取得します。
```
print (VERSION_NAME)
```
返されるパイプラインテンプレートのバージョン名は次のようになります。
```
sha256:41eea21e0d890460b6e6333c8070d7d23d314afd9c7314c165efd41cddff86c7
```
バージョン名の文字列全体をメモしておきます。
Cloud Shell で、次のコマンドを実行します。ここで、PROJECT_ID はプロジェクト ID に置き換えます。
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

on-prem-dataservice-host VM インスタンスにログインします。

gcloud compute ssh on-prem-dataservice-host \
    --zone=us-central1-a \
    --tunnel-through-iap

on-prem-dataservice-host VM インスタンスで、テキストエディタ（vim や nano など）を使用して request_body.json ファイルを作成します。次に例を示します。
```
sudo vim request_body.json
```

request_body.json ファイルに次のテキストを追加します。

{
"displayName": "fungi-image-pipeline-job",
"serviceAccount": "onprem-user-managed-sa@PROJECT_ID.iam.gserviceaccount.com",
"runtimeConfig":{
"gcsOutputDirectory":"gs://pipelines-staging-bucket-PROJECT_ID/pipeline_root/",
"parameterValues": {
   "project": "PROJECT_ID",
   "training_job_display_name": "fungi-image-training-job",
   "worker_pool_specs": [{
      "machine_spec": {
         "machine_type": "n1-standard-4"
      },
      "replica_count": 1,
      "python_package_spec":{
         "executor_image_uri":"us-docker.pkg.dev/vertex-ai/training/tf-cpu.2-8.py310:latest", 
         "package_uris": ["gs://pipelines-staging-bucket-PROJECT_ID/training_package/trainer-0.1.tar.gz"],
         "python_module": "trainer.task",
         "args": ["--data-dir","/mnt/nfs/fungi_dataset/", "--epochs", "10"],
         "env": [{"name": "AIP_MODEL_DIR", "value": "gs://pipelines-staging-bucket-PROJECT_ID/model/"}]
      },
      "nfs_mounts": [{
         "server": "FILESTORE_INSTANCE_IP",
         "path": "/vol1",
         "mount_point": "/mnt/nfs/"
      }]
   }],
   "base_output_dir":"gs://pipelines-staging-bucket-PROJECT_ID",
   "model_artifact_uri":"gs://pipelines-staging-bucket-PROJECT_ID/model/",
   "prediction_container_uri":"us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-8:latest",
   "model_display_name":"fungi-image-model",
   "endpoint_display_name":"fungi-image-endpoint",
   "location": "us-central1",
   "serving_machine_type":"n1-standard-4",
   "network":"projects/PROJECT_NUMBER/global/networks/vertex-networking-vpc"
     }
},
"templateUri": "https://us-central1-kfp.pkg.dev/PROJECT_ID/fungi-repo/custom-image-classification-pipeline/latest",
"templateMetadata": {
   "version":"VERSION_NAME"
}
}

次の値を置き換えます。

PROJECT_ID: プロジェクト ID
PROJECT_NUMBER: プロジェクト番号。これはプロジェクト ID とは異なります。プロジェクト番号は、Google Cloud コンソールでプロジェクトの [プロジェクトの設定] ページを表示すると確認できます。
FILESTORE_INSTANCE_IP: Filestore インスタンスの IP アドレス（10.243.208.2 など）。これは、インスタンスの Filestore インスタンスページで確認できます。
VERSION_NAME: ステップ 2 でメモしたパイプラインテンプレートのバージョン名（sha256:...）。

次のようにファイルを保存します。
- vim を使用している場合は、Esc キーを押してから、「:wq」と入力してファイルを保存し、終了します。
- nano を使用している場合は、「Control+O」と入力して Enter を押してファイルを保存し、「Control+X」と入力して終了します。

テンプレートからパイプライン実行を送信する

on-prem-dataservice-host VM インスタンスで、次のコマンドを実行します。PROJECT_ID はプロジェクト ID に置き換えます。
```
curl -v -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
-d @request_body.json \
https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/pipelineJobs
```
出力は長いですが、主に確認する必要があるのは次の行です。これは、サービスがパイプラインの実行を準備していることを示します。
```
"state": "PIPELINE_STATE_PENDING"
```
パイプラインの実行全体には約 45～50 分かかります。
Google Cloud コンソールの [Vertex AI] セクションで、[パイプライン] ページの [実行] タブに移動します。

[実行] に移動
パイプライン実行の実行名（custom-image-classification-pipeline）をクリックします。

パイプラインの実行ページが表示され、パイプラインのランタイムグラフが表示されます。パイプラインのサマリーが [パイプライン実行分析] ペインに表示されます。

ログの表示方法や、Vertex ML Metadata を使用してパイプラインのアーティファクトの詳細を確認する方法など、ランタイムグラフに表示される情報を理解するには、パイプライン結果の可視化と分析をご覧ください。

クリーンアップ

このチュートリアルで使用したリソースについて Google Cloud アカウントに課金されることのないよう、リソースを含むプロジェクトを削除するか、プロジェクトを維持して個々のリソースを削除します。

プロジェクト内の個々のリソースを削除するには、次のように操作します。

次の手順ですべてのパイプライン実行を削除します。
1. Google Cloud コンソールの [Vertex AI] セクションで、[パイプライン] ページの [実行] タブに移動します。
  
  [実行] に移動
2. 削除するパイプライン実行を選択し、削除アイコンをクリックします。
次の手順でパイプラインテンプレートを削除します。
1. [Vertex AI] セクションで、[パイプライン] ページの [テンプレート] タブに移動します。
  
  [パイプライン] に移動
2. custom-image-classification-pipeline パイプラインテンプレートの横にある操作アイコンをクリックし、[削除] を選択します。
次の手順で Artifact Registry からリポジトリを削除します。
1. [Artifact Registry] ページで、[リポジトリ] タブに移動します。
  
  [リポジトリ] に移動
2. fungi-repo リポジトリを選択し、削除アイコンをクリックします。
次のように、エンドポイントからモデルのデプロイを解除します。
1. [Vertex AI] セクションで、[オンライン予測] ページの [エンドポイント] タブに移動します。
  
  エンドポイントに移動
2. [fungi-image-endpoint] をクリックして、エンドポイントの詳細ページに移動します。
3. モデル（fungi-image-model）の行で、操作アイコンをクリックし、[エンドポイントからモデルのデプロイを解除] を選択します。
4. [エンドポイントからモデルのデプロイを解除] ダイアログで [デプロイ解除] をクリックします。
次の手順でエンドポイントを削除します。
1. [Vertex AI] セクションで、[オンライン予測] ページの [エンドポイント] タブに移動します。
  
  エンドポイントに移動
2. fungi-image-endpoint を選択し、[削除] をクリックします。
次のようにモデルを削除します。
1. [Model Registry] ページに移動します。
  
  [モデル] に移動
2. モデル（fungi-image-model）の行で、操作アイコンをクリックし、[モデルを削除] を選択します。
次の手順でステージングバケットを削除します。
1. [Cloud Storage] ページに移動します。
  
  [Cloud Storage] に移動
2. pipelines-staging-bucket-PROJECT_ID（PROJECT_ID はプロジェクト ID）を選択し、削除アイコンをクリックします。
次の手順で Vertex AI Workbench インスタンスを削除します。
1. [Vertex AI] セクションで、[ワークベンチ] ページの [インスタンス] タブに移動します。
  
  Vertex AI Workbench に移動
2. pipeline-tutorial-PROJECT_ID Vertex AI Workbench インスタンス（PROJECT_ID はプロジェクト ID）を選択し、削除アイコンをクリックします。
次の手順で Compute Engine VM インスタンスを削除します。
1. [Compute Engine] ページに移動します。
  
  Compute Engine に移動
2. on-prem-dataservice-host VM インスタンスを選択し、削除アイコンをクリックします。
次の手順で VPN トンネルを削除します。
1. [VPN] ページに移動します。
  
  [VPN] に移動
2. [VPN] ページで、[Cloud VPN トンネル] タブをクリックします。
3. VPN トンネルのリストで、このチュートリアルで作成した 4 つの VPN トンネルを選択し、削除アイコンをクリックします。
次の手順で HA VPN ゲートウェイを削除します。
1. [VPN] ページで、[Cloud VPN ゲートウェイ] タブをクリックします。
  
  [Cloud VPN ゲートウェイ] に移動
2. VPN ゲートウェイのリストで onprem-vpn-gw1 をクリックします。
3. [Cloud VPN ゲートウェイの詳細] ページで、VPN ゲートウェイの削除アイコンをクリックします。
4. 必要に応じて、矢印をクリックして VPN ゲートウェイのリストに戻り、vertex-networking-vpn-gw1 をクリックします。
5. [Cloud VPN ゲートウェイの詳細] ページで、VPN ゲートウェイの削除アイコンをクリックします。
次の手順で Cloud Router を削除します。
1. [Cloud Router] ページに移動します。
  
  [Cloud Router] に移動
2. Cloud Router のリストで、このチュートリアルで作成した 4 つのルーターを選択します。
3. 削除アイコンをクリックして、ルーターを削除します。
  
  これにより、Cloud Router に接続されている 2 つの Cloud NAT ゲートウェイも削除されます。
次の手順で、vertex-networking-vpc VPC ネットワークと onprem-dataservice-vpc VPC ネットワークへのサービスネットワーキング接続を削除します。
1. [VPC ネットワークピアリング] ページに移動します。
  
  [VPC ネットワークピアリング] に移動
2. [servicenetworking-googleapis-com] を選択します。
3. 接続を削除するには、削除アイコンをクリックします。
次の手順で vertex-networking-vpc VPC ネットワークの pscvertex 転送ルールを削除します。
1. [ロードバランシング] ページの [フロントエンド] タブに移動します。
  
  [フロントエンド] に移動
2. 転送ルールのリストで pscvertex をクリックします。
3. [グローバル転送ルールの詳細] ページで、削除アイコンをクリックします。
次の手順で Filestore インスタンスを削除します。
1. [Filestore] ページに移動します。
  
  [Filestore] に移動
2. image-data-instance インスタンスを選択します。
3. インスタンスを削除するには、操作アイコンをクリックし、[インスタンスを削除] をクリックします。
次の手順で VPC ネットワークを削除します。
1. [VPC ネットワーク] ページに移動します。
  
  [VPC ネットワーク] に移動
2. VPC ネットワークのリストで onprem-dataservice-vpc をクリックします。
3. [VPC ネットワークの詳細] ページで、VPC ネットワークを削除アイコンをクリックします。
  
  ネットワークを削除すると、そのサブネットワーク、ルート、ファイアウォールルールも削除されます。
4. VPC ネットワークのリストで vertex-networking-vpc をクリックします。
5. [VPC ネットワークの詳細] ページで、VPC ネットワークを削除アイコンをクリックします。
次のように、workbench-sa サービスアカウントと onprem-user-managed-sa サービスアカウントを削除します。
1. [サービスアカウント] ページに移動します。
  
  [サービスアカウント] に移動
2. onprem-user-managed-sa サービスアカウントと workbench-sa サービスアカウントを選択し、（削除）をクリックします。

次のステップ

Vertex AI Pipelines を使用して、ML モデルのビルドとデプロイのプロセスをオーケストレートする方法について学習する。
deFungi データセットについて学習する。

Private Service Connect を使用してオンプレミスからトレーニング パイプラインにアクセスする コレクションでコンテンツを整理 必要に応じて、コンテンツの保存と分類を行います。

目標

費用

始める前に

Check for the roles

Grant the roles

VPC ネットワークを作成する

VPC ネットワークが正しく構成されていることを確認する

ハイブリッド接続の構成

HA VPN ゲートウェイを作成する

Cloud Router と Cloud NAT ゲートウェイを作成する

VPN トンネルを作成する

BGP セッションを確立する

vertex-networking-vpc の BGP セッションを確立する

onprem-dataservice-vpc の BGP セッションを確立する

BGP セッションの作成を確認する

onprem-dataservice-vpc の学習されたルートを検証する

vertex-networking-vpc の学習されたルートを検証する

Google API 用の Private Service Connect エンドポイントを作成する

vertex-networking-vpc のカスタムルート アドバタイズを作成する

onprem-dataservice-vpc がアドバタイズされたルートを学習したことを確認する

onprem-dataservice-vpc に VM インスタンスを作成する

VM インスタンスのユーザー管理サービス アカウントを作成する

on-prem-dataservice-host VM インスタンスを作成する

PSC エンドポイントを指すように /etc/hosts ファイルを更新する