Menyiapkan jaringan ambient GKE

Halaman ini menunjukkan cara mengaktifkan ambient networking di cluster baru atau yang sudah ada, mendaftarkan namespace dan workload untuk mengaktifkan pengalihan traffic ambient, serta mengonfigurasi mTLS dan kebijakan otorisasi.

Untuk mengetahui informasi selengkapnya tentang arsitektur, manfaat, dan kemampuan ambient networking, lihat Ringkasan ambient networking.

Prasyarat dan batasan

Sebelum menyiapkan jaringan ambient, tinjau batasan fitur, persyaratan versi, dan batasan cakupan berikut:

  • Versi GKE: Memerlukan GKE versi 1.36.4-gke.1391000 atau yang lebih baru.
  • Versi Google Cloud CLI: Memerlukan Google Cloud CLI versi 592.0.0 atau yang lebih baru.
  • Dukungan Regional: Cluster harus dibuat di region yang didukung oleh Cloud Service Mesh Regional.
  • Interoperabilitas Workload: Workload yang terdaftar dalam jaringan ambient tidak dapat berinteroperasi dengan workload yang diinjeksikan sidecar atau gRPC tanpa proxy.
  • Fitur yang Tidak Didukung:
    • Kolom trafficDistribution Service Kubernetes.
    • Service Headless.
    • GKE Sandbox (gVisor).
  • Pemberitahuan Keamanan: Jika komponen gke-ambient-nriplugin menjadi tidak tersedia di node, autentikasi traffic masuk dan penerapan otorisasi mungkin akan diabaikan.

Sebelum memulai

Selesaikan langkah-langkah penyiapan prasyarat berikut di Cloud de Confiance by S3NS:

  1. Buat atau pilih project.
  2. Aktifkan API yang diperlukan:

    gcloud services enable \
        privateca.googleapis.com \
        gkehub.googleapis.com \
        compute.googleapis.com \
        container.googleapis.com \
        trafficdirector.googleapis.com \
        networkservices.googleapis.com \
        networksecurity.googleapis.com \
        telemetry.googleapis.com \
        monitoring.googleapis.com \
        logging.googleapis.com
    
  3. Mengonfigurasi autentikasi identitas workload terkelola untuk GKE.

Mengaktifkan ambient networking di cluster baru

Jalankan perintah berikut untuk membuat cluster GKE baru dengan jaringan ambient diaktifkan:

  1. Membuat cluster GKE dengan jaringan ambient diaktifkan

    gcloud container clusters create CLUSTER_NAME \
        --machine-type=e2-standard-4 \
        --enable-ambient-networking \
        --enable-dataplane-v2 \
        --enable-fleet \
        --gateway-api=standard \
        --location=CLUSTER_LOCATION \
        --release-channel=rapid \
        --workload-pool=PROJECT_ID.s3ns.svc.id.goog
    

    Dua DaemonSet kini berjalan di namespace gke-managed-ambient.

Mengaktifkan ambient networking di cluster yang ada

Ikuti langkah-langkah berikut untuk mengaktifkan mesh ambient di cluster GKE yang ada:

  1. Pastikan cluster Anda memenuhi persyaratan berikut:

    • Versi 1.36.4-gke.1391000 atau yang lebih baru.
    • GKE Dataplane V2 diaktifkan.
    • Jenis mesin harus e2-standard-4 atau yang lebih besar.
    • Cluster harus ditambahkan ke fleet.
    • Cluster harus mengaktifkan Gateway API dan Workload Identity.
  2. Mengaktifkan jaringan ambien di cluster yang ada:

    gcloud container clusters update CLUSTER_NAME \
        --enable-ambient-networking \
        --location=CLUSTER_LOCATION \
        --enable-fleet
    

    Dua DaemonSet kini berjalan di namespace gke-managed-ambient.

  3. Untuk memverifikasi, arahkan CLI Anda ke cluster:

    gcloud container clusters get-credentials CLUSTER_NAME \
        --location=CLUSTER_LOCATION
    
  4. Dapatkan daemonset di namespace gke-managed-ambient:

    kubectl get daemonset -n gke-managed-ambient
    

    Outputnya mirip dengan:

    NAME                    DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   AGE
    gke-ambient-nriplugin   9         9         9       9            9           4d1h
    gke-ambient-proxy       9         9         9       9            9           4d1h
    

Mendaftarkan namespace untuk jaringan ambien

Ikuti langkah-langkah berikut untuk men-deploy aplikasi contoh dan mengaktifkan pengalihan traffic ambient pada namespace-nya:

  1. Men-deploy aplikasi contoh:

    kubectl apply -f - <<EOF
    apiVersion: v1
    kind: Namespace
    metadata:
      name: ambient-test
    ---
    apiVersion: v1
    kind: ServiceAccount
    metadata:
      name: client
      namespace: ambient-test
    ---
    apiVersion: v1
    kind: ServiceAccount
    metadata:
      name: server
      namespace: ambient-test
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: server
      namespace: ambient-test
      labels:
        app: server
    spec:
      ports:
      - port: 80
        protocol: TCP
      selector:
        app: server
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: client
      namespace: ambient-test
      labels:
        app: client
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: client
      template:
        metadata:
          labels:
            app: client
        spec:
          serviceAccountName: client
          containers:
          - name: nginx
            image: nginx:1.29.6
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: server
      namespace: ambient-test
      labels:
        app: server
    spec:
      replicas: 2
      selector:
        matchLabels:
          app: server
      template:
        metadata:
          labels:
            app: server
        spec:
          serviceAccountName: server
          containers:
          - name: nginx
            image: nginx:1.29.6
            readinessProbe:
              httpGet:
                path: /
                port: 80
    EOF
    
  2. Beri label pada namespace ambient-test untuk mengaktifkan pengalihan traffic melalui proxy ambient GKE:

    kubectl label namespace ambient-test networking.gke.io/dataplane-mode=ambient
    
  3. Pastikan setiap Pod dalam namespace telah dikonfigurasi untuk pengalihan traffic:

    kubectl get pods -n ambient-test -o yaml | grep redirection
    

    Outputnya mirip dengan:

    ambient.networking.gke.io/redirection: enabled
    ambient.networking.gke.io/redirection: enabled
    
  4. Uji traffic klien ke server:

    kubectl exec -it deploy/client -n ambient-test -- \
        /bin/curl -fsLS server.ambient-test.svc.cluster.local
    
  5. Untuk memverifikasi bahwa traffic teks biasa mengalir melalui gke-ambient-proxy, periksa log akses di Logs Explorer dan telusuri nama log gke-ambient-node-proxy-accesslog:

    Buka Logs Explorer

Mengaktifkan mTLS untuk layanan

Setelah mengaktifkan pengalihan traffic untuk workload di namespace, terapkan kebijakan untuk menerapkan enkripsi, autentikasi, dan otorisasi.

  1. Konfigurasikan kebijakan mTLS permisif pada workload sisi server:

    kubectl apply -f - <<EOF
    apiVersion: networking.gke.io/v1
    kind: GCPServerTLSPolicy
    metadata:
      name: server
      namespace: ambient-test
    spec:
      mtlsMode: Permissive
      targetRefs:
      - group: ""
        kind: Pod
        selector:
          matchLabels:
            app: server
    EOF
    

    Kebijakan ini membuat Pod menerima traffic mTLS dan teks biasa. Perhatikan bahwa mTLS permisif menggunakan traffic sniffing untuk mendeteksi apakah traffic adalah mTLS atau teks biasa. Hal ini akan mengganggu traffic aplikasi yang menggunakan TLS-nya sendiri atau protokol "server berbicara terlebih dahulu" seperti MySQL.

  2. Pastikan kebijakan telah diterima oleh pengontrol:

    kubectl describe gcpservertlspolicies -n ambient-test server | grep -A50 Status
    

    Outputnya mirip dengan:

    [...]
    
        Conditions:
        Last Transition Time:  2026-03-25T17:47:30Z
        Message:
        Reason:                Accepted
        Status:                True
        Type:                  Accepted
        Controller Name:         networking.gke.io/dpv2-1n
    Events:
    Type    Reason  Age                   From                   Message
    ----    ------  ----                  ----                   -------
    Normal  Sync    108s (x2 over 2m20s)  sc-dpv2-1n-controller  Sync on Mesh dpv2-1n-fqtx-mesh succeeded
    

    Penyebaran kebijakan dapat memerlukan waktu hingga tiga menit setelah penerimaan pengontrol. Tunggu tiga menit sebelum melanjutkan.

  3. Konfigurasikan kebijakan mTLS sisi klien yang menargetkan layanan:

    kubectl apply -f - <<EOF
    apiVersion: networking.gke.io/v1
    kind: GCPClientTLSPolicy
    metadata:
      name: server-mtls
      namespace: ambient-test
    spec:
      targetRefs:
      - group: ""
        kind: Service
        name: server
      subjectAltNames:
      - uri: spiffe://PROJECT_ID.s3ns.svc.id.goog/ns/ambient-test/sa/server
    EOF
    

    Kebijakan ini mengonfigurasi klien yang terdaftar untuk memulai traffic mTLS ke Service server. Anda mungkin perlu menunggu setidaknya dua menit sebelum melanjutkan ke langkah berikutnya.

  4. Pastikan kebijakan telah diterima oleh pengontrol:

    kubectl describe gcpclienttlspolicies -n ambient-test server-mtls | grep -A50 Status
    

    Outputnya mirip dengan:

    [...]
    Status:
    Conditions:
        Last Transition Time:  2024-10-13T01:15:03Z
        Message:
        Observed Generation:   1
        Reason:                Accepted
        Status:                True
        Type:                  Accepted
    
  5. Uji traffic klien ke server:

    kubectl exec -it deploy/client -n ambient-test -- \
        /bin/curl -fsLS server.ambient-test.svc.cluster.local
    

    Traffic dari Pod yang terdaftar di jaringan ambient ke layanan server di namespace ambient-test sekarang seharusnya menggunakan mTLS.

  6. Untuk memverifikasi bahwa koneksi menggunakan mTLS, periksa log akses di Logs Explorer dan telusuri nama log gke-ambient-node-proxy-accesslog:

    Buka Logs Explorer

  7. Update GCPServerTLSPolicy yang ada untuk mengubah mode dari Permissive menjadi Strict pada layanan server sehingga Pod workload tidak lagi menerima traffic teks biasa:

    kubectl apply -f - <<EOF
    apiVersion: networking.gke.io/v1
    kind: GCPServerTLSPolicy
    metadata:
      name: server
      namespace: ambient-test
    spec:
      mtlsMode: Strict
      targetRefs:
      - group: ""
        kind: Pod
        selector:
          matchLabels:
            app: server
    EOF
    
  8. Pastikan kebijakan telah diterima:

    kubectl describe gcpservertlspolicies -n ambient-test server | grep -A50 Status
    

    Outputnya mirip dengan:

    Name:         server
    
    <...>
    
    UID:                 e4f2a7a3-69aa-4528-8ea6-6f1bf2142011
    Spec:
    Mtls Mode:  Strict
    Target Refs:
    Group:
    Kind:   Pod
    Selector:
      Match Labels:
        App:  server
    Status:
    Ancestors:
        Ancestor Ref:
        Group:
        Kind:   Pod
        Name:   app=server
        Conditions:
        Last Transition Time:  2026-03-25T22:33:54Z
        Message:
        Reason:                Accepted
        Status:                True
        Type:                  Accepted
        Controller Name:         networking.gke.io/dpv2-1n
    Events:
    Type    Reason  Age                  From                   Message
    ----    ------  ----                 ----                   -------
    Normal  Sync    43s (x5 over 4m57s)  sc-dpv2-1n-controller  Sync on Mesh dpv2-1n-2cdi-mesh succeeded
    

    Setiap traffic teks biasa ke Service server Anda kini akan ditolak.

  9. Untuk memverifikasi bahwa traffic teks biasa kini ditolak, kirim traffic ke layanan server dari klien yang TIDAK terdaftar dalam jaringan ambient:

    kubectl create namespace noambient-test && \
    kubectl run -it -n noambient-test --rm curl --image=nginx -- \
        /bin/curl -fsLSv http://server.ambient-test.svc.cluster.local
    

    Koneksi ini akan gagal dengan pesan yang mirip dengan berikut ini:

    * Request completely sent off
    * Empty reply from server
    * shutting down connection #0
    curl: (52) Empty reply from server
    

Menetapkan kebijakan otorisasi Lapisan 4

Untuk menerapkan otorisasi berbasis identitas, pemilik workload menentukan label Pod di pemilih kebijakan. Pemilik namespace menerapkan kebijakan di seluruh namespace tanpa pemilih.

  1. Terapkan kebijakan berikut untuk memastikan bahwa hanya klien yang diizinkan untuk berkomunikasi dengan server:

    kubectl apply -f - <<EOF
    apiVersion: networking.gke.io/v1
    kind: GCPAuthzPolicy
    metadata:
      name: allow-client
      namespace: ambient-test
    spec:
      action: ALLOW
      enforcementLevel: L4
      targetRefs:
      - group: ""
        kind: Pod
        selector:
          matchLabels:
            app: server
      rules:
      - from:
          sources:
          - principals:
            - principalSelector: CLIENT_CERT_URI_SAN
              principal:
                type: Exact
                value: spiffe://PROJECT_ID.s3ns.svc.id.goog/ns/ambient-test/sa/client
    EOF
    

    Kebijakan ini diterapkan pada traffic ke Pod server di namespace ambient-test. Hal ini memastikan bahwa traffic hanya diizinkan dari sumber dengan identitas SPIFFE spiffe://PROJECT_ID.s3ns.svc.id.goog/ns/ambient-test/sa/client.

  2. Pastikan penerapan kebijakan diizinkan dengan mengirimkan permintaan contoh dari akun layanan client.

    kubectl exec -it deploy/client -n ambient-test -- \
        /bin/curl -fsLS server.ambient-test.svc.cluster.local
    
  3. Pastikan penegakan kebijakan tidak diizinkan dengan mengirimkan permintaan sampel dari akun layanan server.

    kubectl exec -it deploy/server -n ambient-test -- \
        /bin/curl -fsLS server.ambient-test.svc.cluster.local
    

    Outputnya mirip dengan:

    curl: (52) Empty reply from server
    command terminated with exit code 52
    
  4. Anda dapat menggunakan Logs Explorer untuk melihat logging penegakan otorisasi. Di konsol Cloud de Confiance , buka halaman Logs Explorer dan telusuri permintaan yang ditolak menggunakan nama log gke-ambient-node-proxy-accesslog:

    resource.type="k8s_container"
    logName="projects/PROJECT_ID/logs/gke-ambient-node-proxy-accesslog"
    jsonPayload.error_details=~"rbac_access_denied"
    

    Buka Logs Explorer

Mengaktifkan metrik Lapisan 4

Anda dapat mengaktifkan pembuatan metrik Lapisan 4 untuk workload di namespace yang terdaftar.

Sebelum mengaktifkan pembuatan metrik Lapisan 4, pastikan Anda telah mengaktifkan telemetry.googleapis.com dan monitoring.googleapis.com serta telah menerapkan networking.gke.io/dataplane-mode=ambient ke namespace.

  1. Aktifkan pembuatan metrik Lapisan 4 untuk workload di namespace:

    kubectl label namespace ambient-test networking.gke.io/ambient-network-metrics=enabled
    
  2. Pastikan pembuatan metrik Lapisan 4 diaktifkan:

    kubectl get namespace ambient-test --show-labels
    

    Outputnya mirip dengan hal berikut ini:

    NAME           STATUS   AGE   LABELS
    ambient-test   Active   15m   kubernetes.io/metadata.name=ambient-test,networking.gke.io/ambient-network-metrics=enabled,networking.gke.io/dataplane-mode=ambient
    

    Setelah Anda menerapkan label networking.gke.io/ambient-network-metrics=enabled dan traffic mengalir di antara workload yang terdaftar, metrik Lapisan 4 akan tersedia di Cloud Monitoring. Anda dapat menggunakan Pemantauan Layanan Jaringan untuk melihat dan menganalisisnya.

  3. Di konsol Cloud de Confiance by S3NS , buka halaman Network Services Monitoring.

    Buka Network Services Monitoring

    Untuk mengetahui informasi selengkapnya, lihat Melihat metrik dan Referensi metrik Pemantauan Network Services.