Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Zabezpieczanie systemu wykrywania zagrożeń w miejscu pracy

1. Wprowadzenie

W tym ćwiczeniu z programowania utworzysz podstawową aplikację demonstracyjną, która pokazuje, jak zintegrować różne usługi Google Cloud na potrzeby usługi znajdującej się w projekcie z ograniczeniami dotyczącymi zgodności. Ten projekt korzysta z tych funkcji zabezpieczeń:

granice danych, które pomagają w stosowaniu środków kontroli w środowiskach regulowanych;
klucze szyfrowania zarządzane przez klienta ( CMEK) do ochrony danych w spoczynku;
chronione węzły GKE i poufne węzły GKE, które pomagają chronić dane podczas przetwarzania;
Workload Identity dla GKE do zarządzania dostępem do Vertex AI, która wykorzystuje Gemini do zadań przetwarzania obrazów;
generatywna AI w Vertex AI do zarządzania wykrywaniem kasków ochronnych w strumieniu wideo.

To ćwiczenie z programowania jest przeznaczone dla deweloperów na wszystkich poziomach, w tym dla początkujących. Będziesz używać interfejsu wiersza poleceń w Google Cloud Shell i kodu w Pythonie. Nie musisz być ekspertem w Pythonie, ale podstawowa wiedza o tym, jak czytać kod, pomoże Ci zrozumieć te koncepcje.

Uwaga: jest to uproszczony dowód koncepcji, a nie aplikacja produkcyjna. W rzeczywistym scenariuszu zastosuj dodatkowe środki ostrożności, takie jak uwierzytelniony i bezpieczny dostęp zewnętrzny do tej usługi.

2. Zanim zaczniesz

Konfiguracja projektu

../shared/_project-setup.md

Uruchamianie Cloud Shell

Cloud Shell to środowisko wiersza poleceń działające w Google Cloud, które jest wstępnie wyposażone w niezbędne narzędzia.

U góry konsoli Google Cloud kliknij Aktywuj Cloud Shell.

Po połączeniu z Cloud Shell uruchom to polecenie, aby zweryfikować uwierzytelnianie w Cloud Shell:

gcloud auth list

Aby potwierdzić, że projekt jest skonfigurowany do użycia z gcloud, uruchom to polecenie:

gcloud config get project

Sprawdź, czy projekt jest zgodny z oczekiwaniami, a następnie uruchom to polecenie, aby ustawić identyfikator projektu:

export PROJECT_ID=$(gcloud config get project)

Wymagane uprawnienia

Konto, którego używasz w tym ćwiczeniu z programowania, musi mieć przypisane te role uprawnień. Te uprawnienia są niezbędne do utworzenia wymaganych zasobów Google Cloud (projektów, folderów, klastrów GKE, kluczy KMS, kont usługi itp.) i skonfigurowania Assured Workload.

Na poziomie organizacji:

roles/assuredworkloads.admin (Administrator Assured Workloads) : do tworzenia i zarządzania samym zasobem Assured Workloads oraz do zapewnienia konfiguracji zgodności.

Na poziomie konta rozliczeniowego (na koncie rozliczeniowym):

roles/billing.accountUser (Użytkownik konta rozliczeniowego) : do łączenia określonego konta rozliczeniowego.

Konfigurowanie zmiennych ćwiczenia z programowania

Aby utworzyć potrzebną infrastrukturę, musisz podać te zmienne środowiskowe:

# 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. Tworzenie podstaw Assured Workloads

Możesz teraz stworzyć podstawy aplikacji w środowisku regulowanym. Użyj Assured Workloads , aby egzekwować wymagania dotyczące zgodności, tworząc kontrolowane środowisko dla swoich zasobów.

Konfigurowanie projektu limitu

Włącz w projekcie limitu interfejs Assured Workloads API. Ten interfejs API jest wymagany do tworzenia zadań Assured Workloads i zarządzania nimi.

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

Tworzenie środowiska Assured Workload

To polecenie tworzy bezpieczną „strefę lądowania” na potrzeby prezentacji. Tworzy 2 nowe projekty Google Cloud w określonym folderze i na koncie rozliczeniowym.

Jeden projekt hostuje klaster GKE i aplikację.
Drugi projekt zarządza kluczami szyfrowania zarządzanymi przez klienta (CMEK).

Od momentu utworzenia automatycznie stosuje do obu projektów określone środki kontroli zgodności z IL5.

Aby utworzyć środowisko zadania, uruchom to polecenie.

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

Włączanie wymaganych interfejsów Google Cloud API

Przed rozpoczęciem kompilacji włącz wymagane interfejsy API dla potrzebnych usług.

To polecenie aktywuje wszystkie usługi niezbędne do tego ćwiczenia z programowania w głównym projekcie zadania.

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. Konfigurowanie infrastruktury GKE

Zbuduj podstawową infrastrukturę, która obsługuje klaster GKE. Obejmuje to skonfigurowanie dedykowanej sieci dla klastra i skonfigurowanie własnych kluczy szyfrowania w celu ochrony danych w węzłach.

Konfigurowanie sieci VPC

Utwórz niestandardowe prywatne środowisko wirtualne w chmurze (VPC) i podsieć. Dzięki temu masz pełną kontrolę nad zakresem adresów IP i możesz mieć pewność, że klaster jest odizolowany zgodnie z oczekiwaniami.

Aby utworzyć sieć VPC i podsieć w określonym regionie, uruchom te polecenia.

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

Konfigurowanie szyfrowania za pomocą Cloud KMS

Aby spełnić rygorystyczne wymagania dotyczące zgodności danych w spoczynku, użyj kluczy szyfrowania zarządzanych przez klienta (CMEK). Dzięki temu masz bezpośrednią kontrolę nad kluczami używanymi do szyfrowania dysków rozruchowych węzłów GKE.

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

Klucz szyfrowania znajduje się w projekcie KMS innym niż usługa, która musi go używać, dlatego agent usługi Google Compute Engine w projekcie zadania musi mieć dostęp do klucza.

Musisz wyraźnie przyznać agentowi usługi GCE z projektu zadania uprawnienie do używania tego klucza. To polecenie dodaje do klucza powiązanie uprawnień, przyznając agentowi usługi niezbędną rolę.

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

Konfigurowanie konta usługi węzła 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. Tworzenie i konfigurowanie klastra GKE

Teraz możesz utworzyć klaster GKE. To polecenie udostępnia klaster GKE z włączonymi kilkoma funkcjami zabezpieczeń.

Może to potrwać kilka minut, ponieważ Google Cloud udostępnia węzły i platformę sterującą.

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

Łączenie z nowym klastrem

Aby wchodzić w interakcje z nowym klastrem, skonfiguruj lokalne narzędzie wiersza poleceń kubectl.

To polecenie pobiera dane logowania i punkt końcowy klastra oraz automatycznie konfiguruje lokalny plik kubeconfig. Po uruchomieniu tego polecenia wszystkie polecenia kubectl będą kierowane do nowego klastra GKE.

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

6. Konfigurowanie tożsamości aplikacji

Aby połączyć konto usługi Kubernetes z kontem usługi Google Cloud IAM, skonfiguruj Workload Identity.

Tworzenie kont usługi

Utwórz w klastrze dedykowane konto usługi Kubernetes (KSA).

export GKE_NAMESPACE=default
export GKE_SA=ppe-sa

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

Następnie aplikacja potrzebuje tożsamości w Google Cloud. Utwórz konto usługi Google Cloud IAM na potrzeby aplikacji. Po utworzeniu konta usługi przyznaj mu niezbędne role.

# 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"

Umożliwianie kontu usługi Kubernetes przyjmowania tożsamości konta IAM

Po utworzeniu obu kont usługi ostatnim krokiem jest utworzenie między nimi połączenia. Jest to proces dwuetapowy. Najpierw dodaj do konta usługi Google Cloud uprawnienia.

# 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}]"

Następnie dodaj adnotacje do konta usługi Kubernetes.

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

Po wykonaniu tych czynności każdy pod działający w klastrze z kontem usługi Kubernetes może teraz uzyskać dostęp do interfejsu Vertex API.

Uwaga: aby uprościć tę konfigurację, można wyeliminować przyjmowanie tożsamości konta usługi. Szczegóły i ograniczenia znajdziesz tutaj.

7. Kompilowanie i wdrażanie aplikacji

Czas spakować aplikację, zapisać ją i wdrożyć w klastrze GKE.

Tworzenie repozytorium Artifact Registry

Zanim uruchomisz aplikację, spakuj ją jako kontener Dockera i zapisz w repozytorium Artifact Registry. Aby utworzyć to repozytorium, użyj tego polecenia.

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"

Musisz wyraźnie przyznać kontu usługi używanemu przez węzły GKE uprawnienie do odczytu z nowego repozytorium.

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"

Kompilowanie i przekazywanie obrazu Dockera

Skompiluj i prześlij obraz Dockera do repozytorium. Najpierw sklonuj kod źródłowy i skompiluj obraz kontenera. Następnie dodaj do niego tag z pełną ścieżką Artifact Registry i prześlij go do utworzonego wcześniej repozytorium.

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

Wdrażanie w GKE

Gdy obraz kontenera jest dostępny w Artifact Registry, ostatnim krokiem jest poinstruowanie GKE, aby go pobrał i uruchomił. Aby to zrobić, zdefiniuj zasoby aplikacji w pliku manifestu Kubernetes i zastosuj go do klastra. To polecenie tworzy obiekty Deployment i Service zdefiniowane w pliku.

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. Testowanie aplikacji

Ostatnim krokiem jest uzyskanie dostępu do aplikacji demonstracyjnej i jej przetestowanie. Obejmuje to pobranie zewnętrznego adresu IP przypisanego do usługi i interakcję z nią za pomocą prostego frontendu.

Pobieranie zewnętrznego adresu IP usługi

Pobierz zewnętrzny adres IP udostępnionej usługi (udostępnianie trwa ok. 30 sekund).

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

Lokalne uruchamianie frontendu

W tej prezentacji frontend to prosta strona HTML/JavaScript, która nie jest częścią wdrożenia GKE. Jest ona przeznaczona do uruchamiania na komputerze lokalnym.

W aplikacji produkcyjnej frontend powinien być obsługiwany przez GCP. Na komputerze lokalnym:

# 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

Otwórz w Chrome adres http://localhost:8001/index.html.

9. Czyszczenie

Aby uniknąć dalszych opłat, usuń zasoby utworzone w tym ćwiczeniu z programowania.

Niszczenie klastra GKE

Aby usunąć całą aplikację, wystarczy usunąć klaster GKE. Aby to zrobić, uruchom to polecenie:

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

Usuwanie Assured Workloads

Aby usunąć wszystkie zasoby powiązane z Assured Workload, uruchom te polecenia.

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

Misja zakończona! Udało Ci się utworzyć system wykrywania bezpieczeństwa w miejscu pracy w branżach regulowanych, który używa Gemini do wykrywania kasków ochronnych.

Co udało Ci się osiągnąć:

Ochrona danych i prywatność: udostępniłeś(-aś) poufny węzeł GKE z CMEK.
Granice danych: włączyłeś(-aś) środki kontroli zgodności platformy w środowisku regulowanym.