Zabezpieczanie systemu wykrywania zagrożeń w miejscu pracy

1. Wprowadzenie

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

To ćwiczenie jest przeznaczone dla deweloperów na wszystkich poziomach zaawansowania, 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: to uproszczony dowód koncepcji, a nie aplikacja produkcyjna. W rzeczywistych scenariuszach stosuj dodatkowe środki ostrożności, takie jak uwierzytelniony i zabezpieczony dostęp zewnętrzny do tej usługi.

2. Zanim zaczniesz

Konfigurowanie projektu

../shared/_project-setup.md

Uruchom Cloud Shell

Cloud Shell to środowisko wiersza poleceń działające w Google Cloud, które zawiera niezbędne narzędzia.

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

404e4cce0f23e5c5.png

  1. Po połączeniu z Cloud Shell uruchom to polecenie, aby zweryfikować uwierzytelnianie w Cloud Shell:
gcloud auth list
  1. Aby sprawdzić, czy projekt jest skonfigurowany do używania z gcloud, uruchom to polecenie:
gcloud config get project
  1. 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 samouczku, 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ług itp.) i skonfigurowania Assured Workload.

Na poziomie organizacji:

  • roles/assuredworkloads.admin (Administrator zadań Assured Workloads): umożliwia tworzenie zasobów Assured Workloads i zarządzanie nimi, a także zapewnianie konfiguracji zgodności.

Na poziomie konta rozliczeniowego (na koncie rozliczeniowym):

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

Konfigurowanie zmiennych ćwiczeń 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 zadań Assured Workloads

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

Konfigurowanie projektu limitu

Włącz interfejs Assured Workloads API w projekcie z limitami. 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 zadań Assured Workloads

To polecenie tworzy bezpieczną „strefę docelową” dla wersji demonstracyjnej. W określonym folderze i na określonym koncie rozliczeniowym utworzy 2 nowe projekty Google Cloud.

  • Jeden projekt hostuje klaster GKE i aplikację.
  • W drugim projekcie zarządzasz kluczami szyfrowania zarządzanymi przez klienta (CMEK).

Automatycznie stosuje określone wymagania zgodności z IL5 w obu projektach od momentu ich utworzenia.

Aby utworzyć środowisko zadań, 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 tworzenia włącz wymagane interfejsy API dla potrzebnych usług.

Poniższe polecenie aktywuje w projekcie podstawowego obciążenia wszystkie usługi niezbędne do tego laboratorium.

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 infrastrukturę podstawową, która obsługuje klaster GKE. Obejmuje to skonfigurowanie dedykowanej sieci dla klastra i własnych kluczy szyfrowania w celu ochrony danych na węzłach.

Konfigurowanie sieci VPC

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

Uruchom te polecenia, aby utworzyć sieć VPC i podsieć w wybranym regionie.

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 w przypadku danych w spoczynku, używaj 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 innym projekcie KMS niż usługa, która musi go używać, więc agent usługi Google Compute Engine w projekcie obciążenia musi mieć do niego dostęp.

Musisz wyraźnie przyznać agentowi usługi GCE z projektu obciążenia uprawnienia do używania tego klucza. Poniższe polecenie dodaje do klucza powiązanie zasad 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 korzystać z nowego klastra, 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. Konfiguracja tożsamości aplikacji

Aby połączyć konto usługi Kubernetes z kontem usługi Cloud IAM w Google Cloud, 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 musi mieć tożsamość 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 usługi uprawnień

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

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

Po drugie, dodaj adnotację 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 będzie mieć dostęp do interfejsu Vertex API.

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

7. Tworzenie 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 przechowuj w repozytorium Artifact Registry. Aby utworzyć to repozytorium, użyj poniższego 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 uprawnienia 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"

Tworzenie i przekazywanie obrazu Dockera

Utwórz obraz Dockera i przenieś go 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 będzie dostępny w Artifact Registry, ostatnim krokiem jest poinstruowanie GKE, aby go pobrał i uruchomił. Możesz to zrobić, definiując zasoby aplikacji w pliku manifestu Kubernetes i stosując go w klastrze. 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 nim za pomocą prostego interfejsu.

Pobieranie zewnętrznego adresu IP usługi

Sprawdź zewnętrzny adres IP udostępnionej usługi (udostępnienie trwa około 30 sekund).

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

Lokalne uruchamianie interfejsu

Na potrzeby tej demonstracji frontend to prosta strona HTML/JavaScript, która nie jest częścią wdrożenia GKE. Jest on przeznaczony do uruchamiania na komputerze lokalnym.

W aplikacji produkcyjnej interfejs powinien być obsługiwany przez GCP. Na urządzeniu 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 stronę http://localhost:8001/index.html.

9. Czyszczenie

Aby uniknąć bieżących opłat, usuń zasoby utworzone w tym laboratorium.

Usuwanie klastra GKE

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

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

Usuwanie zadań Assured Workloads

Aby usunąć wszystkie zasoby powiązane z Assured Workloads, 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 ukończona! Udało Ci się utworzyć system wykrywania bezpieczeństwa w miejscu pracy w branżach podlegających regulacjom, który wykorzystuje Gemini do wykrywania kasków ochronnych.

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

  • Ochrona danych i prywatność: masz węzeł GKE poufnego z kluczem CMEK
  • Granice danych: w środowisku podlegającym regulacjom włączono ustawienia zgodności platformy z przepisami.

Dokumentacja