Mengamankan Sistem Deteksi Keselamatan di Tempat Kerja

1. Pengantar

Dalam Codelab ini, Anda akan membuat aplikasi demonstrasi dasar yang menggambarkan cara mengintegrasikan berbagai layanan Google Cloud untuk layanan yang berada di project dengan batasan kepatuhan. Project ini menggunakan kemampuan keamanan berikut:

• Batas Data untuk membantu menangani kontrol bagi lingkungan yang diatur
• Kunci Enkripsi yang Dikelola Pelanggan ( CMEK) untuk mengamankan data saat tidak digunakan;
• Node Terlindungi GKE dan Node Rahasia GKE untuk membantu mengamankan data selama pemrosesan;
• Workload Identity untuk GKE guna mengelola akses ke Vertex AI, yang menggunakan Gemini untuk tugas pemrosesan gambar.
• AI Generatif di Vertex AI untuk mengelola deteksi helm pengaman dari aliran video

Codelab ini ditujukan bagi developer dari semua level, termasuk pemula. Anda akan menggunakan antarmuka command line di Google Cloud Shell dan kode Python. Anda tidak perlu menjadi pakar Python, tetapi pemahaman dasar tentang cara membaca kode akan membantu Anda memahami konsepnya.

Catatan: Ini adalah proof-of-concept yang disederhanakan, bukan aplikasi produksi. Terapkan tindakan pencegahan tambahan seperti akses eksternal yang diautentikasi dan diamankan ke layanan ini dalam skenario dunia nyata.

2. Sebelum memulai

Penyiapan project

../shared/_project-setup.md

Mulai Cloud Shell

Cloud Shell adalah lingkungan command line yang berjalan di Google Cloud yang telah dilengkapi dengan alat yang diperlukan.

1. Klik Activate Cloud Shell di bagian atas konsol Google Cloud:

2. Setelah terhubung ke Cloud Shell, jalankan perintah ini untuk memverifikasi autentikasi Anda di Cloud Shell:

gcloud auth list

3. Jalankan perintah berikut untuk mengonfirmasi bahwa project Anda dikonfigurasi untuk digunakan dengan gcloud:

gcloud config get project

4. Pastikan project sudah sesuai, lalu jalankan perintah di bawah untuk menetapkan project id Anda:

export PROJECT_ID=$(gcloud config get project)

Izin IAM yang diperlukan

Akun yang Anda gunakan untuk codelab ini harus memiliki peran IAM berikut. Izin ini diperlukan untuk membuat resource Google Cloud yang diperlukan (project, folder, cluster GKE, kunci KMS, akun layanan, dll.) dan mengonfigurasi Assured Workload.

Di Tingkat Organisasi:

• roles/assuredworkloads.admin (Administrator Assured Workloads): Untuk membuat dan mengelola resource Assured Workloads itu sendiri, memastikan konfigurasi kepatuhan.

Di Tingkat Akun Penagihan (di Akun Penagihan Anda):

• roles/billing.accountUser (Pengguna Akun Penagihan): Untuk menautkan akun penagihan yang ditentukan.

Mengonfigurasi variabel Codelab

Untuk membuat infrastruktur yang diperlukan, Anda harus menyediakan variabel lingkungan berikut:

# The ID of the Billing Account in the format (XXXXXX-XXXXXX-XXXXXX).
# This value will be used to attach in the projects created using Assured Workloads
export BILLING_ACCOUNT=

# The ID of a Google Cloud Platform organization
# Run `gcloud organizations list` to check all your available organizations
export GCP_ORGANIZATION=

# The numeric ID of a folder where the Assured Workloads will create the resources.
export FOLDER_ID=

# Region where the application will be deployed.
# Since you are using Assured Workloads, you MUST use one of the valid locations as described here: <https://docs.cloud.google.com/assured-workloads/docs/locations>
export REGION="us-central1"

# The ID of an existing Google Cloud project to be used for API quota and billing purposes.
# This project will only be used to enable the Assured Workloads API and create an Assured Workload.
export QUOTA_PROJECT_ID=

# Random suffix used to avoid naming collisions when creating the GCP projects.
export RANDOM_SUFFIX=$(cat /dev/urandom | tr -dc 'a-z0-9' | head -c 5 ; echo)

# The ID of the projects that will be created using Assured Workloads.
# You can modify this value if you want a custom id.
export PROJECT_ID="il5-gemini-vision-aw-${RANDOM_SUFFIX}"
export KMS_PROJECT_ID="il5-gemini-vision-kms-${RANDOM_SUFFIX}"

3. Membuat fondasi Assured Workloads

Sekarang Anda dapat meletakkan dasar untuk aplikasi Anda di lingkungan yang diatur. Gunakan Assured Workloads untuk membantu menerapkan persyaratan kepatuhan dengan membuat lingkungan terkontrol untuk resource Anda.

Mengonfigurasi project kuota Anda

Aktifkan Assured Workloads API di project kuota Anda. API ini diperlukan untuk membuat dan mengelola Assured Workloads.

gcloud services enable assuredworkloads.googleapis.com \
  --project="${QUOTA_PROJECT_ID}"

Buat lingkungan Assured Workload

Perintah berikut akan membuat 'zona landing' yang aman untuk demo Anda. Hal ini akan membuat dua project Google Cloud baru di folder dan akun penagihan yang Anda tentukan.

• Satu project menghosting cluster dan aplikasi GKE Anda.
• Project lainnya mengelola Kunci Enkripsi yang Dikelola Pelanggan (CMEK) Anda.

Fitur ini secara otomatis menerapkan kontrol kepatuhan IL5 yang ditentukan ke kedua project sejak saat project dibuat.

Jalankan perintah berikut untuk membuat lingkungan workload.

export ASSURED_WORKLOAD_ID=$(gcloud assured workloads create \
    --project="${QUOTA_PROJECT_ID}" \
    --display-name="DoD IL5 Gemini Vision Demo" \
    --compliance-regime="IL5" \
    --billing-account="billingAccounts/${BILLING_ACCOUNT}" \
    --location="${REGION}" \
    --organization="${GCP_ORGANIZATION}" \
    --provisioned-resources-parent="folders/${FOLDER_ID}" \
    --resource-settings="consumer-project-id=${PROJECT_ID},consumer-project-name=DoD IL5 Workloads,encryption-keys-project-id=${KMS_PROJECT_ID},encryption-keys-project-name=DoD IL5 KMS" \
    --labels="codelab=gemini-vision-demo" \
    --format="value(name)")

echo "Assured Workload created: ${ASSURED_WORKLOAD_ID}"

export WORKLOAD_FOLDER_ID=$(gcloud assured workloads describe ${ASSURED_WORKLOAD_ID} \
    --location="${REGION}" \
    --project="${QUOTA_PROJECT_ID}" \
    --format="json" | grep -B 1 "CONSUMER_FOLDER" | grep -oE "[0-9]{10,}")

echo "Assured Workload folder created: ${WORKLOAD_FOLDER_ID}"

gcloud projects create "${PROJECT_ID}" \
    --folder="${WORKLOAD_FOLDER_ID}" \
    --name="DoD IL5 Workloads"

gcloud billing projects link "${PROJECT_ID}" \
    --billing-account="${BILLING_ACCOUNT}"

export PROJECT_NUMBER=$(gcloud projects describe "${PROJECT_ID}" --format="value(projectNumber)")

Mengaktifkan Google Cloud API yang diperlukan

Sebelum membangun, aktifkan API yang diperlukan untuk layanan yang dibutuhkan.

Perintah di bawah mengaktifkan semua layanan yang diperlukan untuk Codelab ini dalam project beban kerja utama Anda.

gcloud services enable \
    aiplatform.googleapis.com \
    artifactregistry.googleapis.com \
    cloudkms.googleapis.com \
    compute.googleapis.com \
    container.googleapis.com \
    iam.googleapis.com \
    logging.googleapis.com \
    monitoring.googleapis.com \
    --project="${PROJECT_ID}"

4. Penyiapan infrastruktur GKE

Bangun infrastruktur inti yang mendukung cluster GKE Anda. Hal ini mencakup penyiapan jaringan khusus untuk cluster Anda dan mengonfigurasi kunci enkripsi Anda sendiri untuk melindungi data di node Anda.

Mengonfigurasi jaringan VPC

Buat Virtual Private Cloud (VPC) dan subnetwork kustom. Pendekatan ini memberi Anda kontrol penuh atas rentang alamat IP dan memastikan cluster Anda diisolasi sesuai keinginan.

Jalankan perintah berikut untuk membuat jaringan VPC dan subnetwork dalam region yang Anda tentukan.

export GKE_NETWORK_NAME="il5-gke-network"
export GKE_SUBNETWORK_NAME="il5-gke-subnet"

gcloud compute networks create "${GKE_NETWORK_NAME}" \
    --description="VPC network for GKE cluster in DoD IL5 Assured Workload" \
    --subnet-mode="custom" \
    --project="${PROJECT_ID}"

gcloud compute networks subnets create "${GKE_SUBNETWORK_NAME}" \
    --network="${GKE_NETWORK_NAME}" \
    --range="10.10.0.0/20" \
    --region="${REGION}" \
    --description="Subnet for GKE cluster nodes in DoD IL5 Assured Workload" \
    --project="${PROJECT_ID}"

Mengonfigurasi enkripsi dengan Cloud KMS

Untuk memenuhi persyaratan kepatuhan yang ketat untuk data saat istirahat, gunakan Kunci Enkripsi yang Dikelola Pelanggan (CMEK). Tindakan ini memberi Anda kontrol langsung atas kunci yang digunakan untuk mengenkripsi boot disk node GKE Anda.

export KMS_KEYRING_NAME="il5_gke_key_ring"
export KMS_KEY_NAME="il5_gke_key"

gcloud kms keyrings create "${KMS_KEYRING_NAME}" \
    --location="$REGION" \
    --project="${KMS_PROJECT_ID}"

gcloud kms keys create "${KMS_KEY_NAME}" \
    --keyring="${KMS_KEYRING_NAME}" \
    --location="${REGION}" \
    --purpose="encryption" \
    --project="${KMS_PROJECT_ID}"

Karena kunci enkripsi ada di project KMS yang terpisah dari layanan yang perlu menggunakannya, agen layanan Google Compute Engine di project beban kerja memerlukan akses ke kunci tersebut.

Anda harus memberikan izin secara eksplisit kepada agen layanan GCE dari project beban kerja untuk menggunakan kunci ini. Perintah di bawah menambahkan binding kebijakan IAM ke kunci, sehingga memberikan peran yang diperlukan kepada agen layanan.

gcloud kms keys add-iam-policy-binding "${KMS_KEY_NAME}" \
    --location="${REGION}" \
    --keyring="${KMS_KEYRING_NAME}" \
    --member="serviceAccount:service-${PROJECT_NUMBER}@compute-system.iam.gserviceaccount.com" \
    --role="roles/cloudkms.cryptoKeyEncrypterDecrypter" \
    --project="${KMS_PROJECT_ID}"

Mengonfigurasi akun layanan node GKE

export GKE_NODE_SA=gke-node-sa

gcloud iam service-accounts create "${GKE_NODE_SA}" \
    --display-name="GKE Node Service Account" \
    --project="${PROJECT_ID}"

gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
    --member="serviceAccount:${GKE_NODE_SA}@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/logging.logWriter"

gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
    --member="serviceAccount:${GKE_NODE_SA}@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/monitoring.metricWriter"

5. Pembuatan dan konfigurasi cluster GKE

Sekarang, Anda dapat membuat cluster GKE. Perintah berikut menyediakan cluster GKE dengan beberapa fitur keamanan yang diaktifkan.

Proses ini memerlukan waktu beberapa menit untuk diselesaikan karena Google Cloud menyediakan node dan bidang kontrol.

export GKE_CLUSTER=ppe-app

gcloud beta container clusters create "${GKE_CLUSTER}" \
    --project="$PROJECT_ID" \
    --region="$REGION" \
    --service-account="${GKE_NODE_SA}@${PROJECT_ID}.iam.gserviceaccount.com" \
    --release-channel="regular" \
    --machine-type="n2d-standard-4" \
    --image-type="COS_CONTAINERD" \
    --disk-type="pd-ssd" \
    --disk-size="50" \
    --boot-disk-kms-key="projects/${KMS_PROJECT_ID}/locations/${REGION}/keyRings/${KMS_KEYRING_NAME}/cryptoKeys/${KMS_KEY_NAME}" \
    --metadata disable-legacy-endpoints=true \
    --num-nodes="1" \
    --network="projects/${PROJECT_ID}/global/networks/${GKE_NETWORK_NAME}" \
    --subnetwork="projects/${PROJECT_ID}/regions/${REGION}/subnetworks/${GKE_SUBNETWORK_NAME}" \
    --security-posture="standard" \
    --workload-vulnerability-scanning="disabled" \
    --workload-pool="${PROJECT_ID}.svc.id.goog" \
    --workload-metadata=GKE_METADATA \
    --addons="HorizontalPodAutoscaling,HttpLoadBalancing,NodeLocalDNS,GcePersistentDiskCsiDriver" \
    --max-surge-upgrade=1 \
    --max-unavailable-upgrade=0 \
    --binauthz-evaluation-mode="DISABLED" \
    --no-enable-basic-auth \
    --enable-autoupgrade \
    --enable-autorepair \
    --enable-confidential-nodes \
    --confidential-node-type=sev \
    --enable-ip-access \
    --enable-ip-alias \
    --enable-managed-prometheus \
    --enable-dns-access \
    --enable-shielded-nodes \
    --shielded-integrity-monitoring \
    --shielded-secure-boot

Menghubungkan ke cluster baru

Untuk berinteraksi dengan cluster baru, konfigurasi alat command line kubectl lokal Anda.

Perintah ini mengambil kredensial dan endpoint cluster, serta mengonfigurasi file kubeconfig lokal Anda secara otomatis. Setelah menjalankan perintah ini, semua perintah kubectl yang Anda jalankan akan diarahkan ke cluster GKE baru.

gcloud container clusters get-credentials "${GKE_CLUSTER}" \
    --region="${REGION}" \
    --project="${PROJECT_ID}" \
    --dns-endpoint

6. Konfigurasi identitas aplikasi

Untuk menghubungkan akun layanan Kubernetes ke akun layanan IAM Google Cloud, konfigurasi Workload Identity.

Membuat akun layanan

Buat Akun Layanan Kubernetes (KSA) khusus di dalam cluster Anda.

export GKE_NAMESPACE=default
export GKE_SA=ppe-sa

kubectl create sa "${GKE_SA}" --namespace="${GKE_NAMESPACE}"

Selanjutnya, aplikasi Anda memerlukan identitas dalam Google Cloud. Buat akun layanan IAM Google Cloud untuk aplikasi. Setelah membuat akun layanan, berikan peran yang diperlukan ke akun layanan tersebut.

# Create GCP service account
gcloud iam service-accounts create "${GKE_SA}" \
    --project="${PROJECT_ID}"
# Grant necessary roles
gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
    --member="serviceAccount:${GKE_SA}@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/aiplatform.user"

Mengizinkan Akun Layanan Kubernetes meniru identitas Akun Layanan IAM

Setelah kedua akun layanan dibuat, langkah terakhir adalah membuat link di antara keduanya. Proses ini terdiri dari dua bagian. Pertama, tambahkan kebijakan IAM ke Akun Layanan Google Cloud Anda.

# Allow the Kubernetes service account to act as GCP service account by using Workload Identity
gcloud iam service-accounts add-iam-policy-binding "${GKE_SA}@${PROJECT_ID}.iam.gserviceaccount.com" \
    --project="${PROJECT_ID}" \
    --role="roles/iam.workloadIdentityUser" \
    --member="serviceAccount:${PROJECT_ID}.svc.id.goog[${GKE_NAMESPACE}/${GKE_SA}]"

Kedua, beri anotasi pada Akun Layanan Kubernetes Anda.

kubectl annotate --namespace="${GKE_NAMESPACE}" serviceaccount "$GKE_SA" \
    iam.gke.io/gcp-service-account="${GKE_SA}@${PROJECT_ID}.iam.gserviceaccount.com"

Setelah selesai, setiap pod yang berjalan di cluster Anda dengan akun layanan Kubernetes kini dapat mengakses Vertex API.

Catatan: Peniruan identitas akun layanan dapat dihilangkan untuk menyederhanakan konfigurasi ini. Lihat di sini untuk mengetahui detail dan batasannya.

7. Build dan deployment aplikasi

Sekarang saatnya memaketkan aplikasi, menyimpannya, dan men-deploy-nya ke cluster GKE Anda.

Membuat repositori Artifact Registry

Sebelum dapat menjalankan aplikasi, paketkan sebagai container Docker dan simpan di dalam repositori Artifact Registry. Gunakan perintah di bawah untuk membuat repositori ini.

export REPOSITORY_ID=ppe-repo

gcloud artifacts repositories create "${REPOSITORY_ID}" \
  --repository-format=docker \
  --location="${REGION}" \
  --project="${PROJECT_ID}" \
  --description="Regional Docker repo for PPE App"

Anda harus memberikan izin secara eksplisit kepada akun layanan yang digunakan oleh node GKE untuk membaca dari repositori baru Anda.

gcloud artifacts repositories add-iam-policy-binding "${REPOSITORY_ID}" \
    --location="${REGION}" \
    --role="roles/artifactregistry.reader" \
    --project="${PROJECT_ID}" \
    --member="serviceAccount:${GKE_NODE_SA}@${PROJECT_ID}.iam.gserviceaccount.com"

Membangun dan mengirim image Docker

Bangun dan kirim image Docker ke repositori. Pertama, clone kode sumber dan bangun image container. Kemudian, beri tag dengan jalur Artifact Registry lengkapnya, dan kirim ke repositori yang Anda buat sebelumnya.

git clone https://github.com/GoogleCloudPlatform/next-26-sessions.git

cd BRK3-034-workplace-safety

cd ppe

export IMAGE_TAG="${REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_ID}/ppe-app:v15"
docker build -t "${IMAGE_TAG}" .
docker push "${IMAGE_TAG}"

Men-deploy ke GKE

Dengan image container yang tersedia di Artifact Registry, langkah terakhir adalah menginstruksikan GKE untuk menarik dan menjalankannya. Hal ini dicapai dengan menentukan resource aplikasi Anda dalam file manifes Kubernetes dan menerapkannya ke cluster. Perintah ini membuat objek Deployment dan Service yang ditentukan dalam file.

Perintah ini men-deploy endpoint analisis untuk akses di luar cluster GKE. Pastikan endpoint ini tidak dapat diakses dari jaringan yang tidak tepercaya seperti VPC default. Aplikasi produksi harus mempertimbangkan untuk menggunakan pengamanan tambahan seperti Model Armor.

export GKE_DEPLOY=ppe-detector

cat <<EOF | kubectl apply -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ${GKE_DEPLOY}
spec:
  replicas: 2
  selector:
    matchLabels:
      app: ${GKE_DEPLOY}
  template:
    metadata:
      labels:
        app: ${GKE_DEPLOY}
    spec:
      serviceAccountName: ${GKE_SA}
      containers:
      - name: ${GKE_DEPLOY}
        image: ${IMAGE_TAG}
        env:
        - name: PROJECT_ID
          value: ${PROJECT_ID}
        - name: LOCATION
          value: ${REGION}
        ports:
        - containerPort: 8080
        resources:
          requests:
            cpu: "250m"
            memory: "512Mi"
          limits:
            cpu: "500m"
            memory: "1Gi"
---
apiVersion: v1
kind: Service
metadata:
  name: ${GKE_DEPLOY}
spec:
  type: LoadBalancer
  selector:
    app: ${GKE_DEPLOY}
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080
EOF

8. Menguji aplikasi

Langkah terakhir adalah mengakses dan menguji aplikasi demo. Hal ini melibatkan pengambilan alamat IP eksternal yang ditetapkan ke layanan dan berinteraksi dengannya melalui frontend sederhana.

Mengambil IP eksternal layanan

Dapatkan IP eksternal layanan yang diekspos (membutuhkan waktu sekitar 30 detik untuk penyediaan)

export IP_ADDRESS=$(kubectl get service "${GKE_DEPLOY}" -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
echo $IP_ADDRESS

Menjalankan frontend secara lokal

Untuk demonstrasi ini, frontend adalah halaman HTML/JavaScript sederhana yang bukan bagian dari deployment GKE. Dirancang untuk berjalan di komputer lokal Anda.

Frontend harus ditayangkan dari GCP dalam aplikasi produksi. Di komputer lokal:

# Update the index.html file with the server IP address
cd frontend

# For Linux
sed -i "s#\(const BACKEND_URL = \"http://\)[^/]\+\(\/analyze\";\)#\1${IP_ADDRESS}\2#g" "index.html"

# For MacOS
#sed -i '' "s#\(const BACKEND_URL = #\"http://\)[^/]*\(\/analyze\";\)#\1${IP_ADDRESS}\2#g" "index.html"

python3 -m http.server 8001

Buka http://localhost:8001/index.html di Chrome.

9. Pembersihan

Untuk menghindari biaya berkelanjutan, hapus resource yang dibuat di codelab ini.

Menghancurkan cluster GKE

Untuk menghapus seluruh aplikasi, Anda hanya perlu menghapus cluster GKE. Untuk melakukannya, jalankan:

gcloud container clusters delete "${GKE_CLUSTER}" \
    --region="$REGION" \
    --project="${PROJECT_ID}"

Menghapus Assured Workloads

Jalankan perintah berikut untuk menghapus semua resource terkait Assured Workload.

# Workload project deletion
gcloud billing projects unlink "${PROJECT_ID}"
gcloud projects delete "${PROJECT_ID}"

# KMS project deletion
gcloud billing projects unlink "${KMS_PROJECT_ID}"
gcloud projects delete "${KMS_PROJECT_ID}"

# Assured Workload folder deletion
gcloud resource-manager folders delete ${WORKLOAD_FOLDER_ID} --quiet

# Assured Workload deletion
gcloud assured workloads delete "${ASSURED_WORKLOAD_ID}" \
    --location="${REGION}" \
    --organization="${GCP_ORGANIZATION}" \
    --project="${QUOTA_PROJECT_ID}"

10. Selamat

Misi Selesai! Anda telah berhasil membangun sistem deteksi keselamatan tempat kerja untuk industri yang diatur yang menggunakan Gemini untuk mendeteksi helm.

Yang telah Anda capai:

• Perlindungan dan privasi data: Anda menyediakan node Confidential GKE dengan CMEK
• Batasan Data: Anda mengaktifkan kontrol kepatuhan platform untuk lingkungan yang diatur

Dokumen referensi

• Mengenkripsi data workload aktif dengan Confidential GKE Node
• Menggunakan kebijakan organisasi kustom
• Ringkasan Batas Data melalui Assured Workloads