Versi 1.19

Versi yang tersedia

1.20 (terbaru)
1.19
1.18
1.17
1.16
1.15
1.14
1.13
1.12
1.12

219}

Mengintegrasikan IAP dengan Anthos Service Mesh

Panduan ini menjelaskan cara mengintegrasikan Identity-Aware Proxy (IAP) dengan Anthos Service Mesh. Integrasi IAP dengan Anthos Service Mesh memungkinkan Anda mengakses layanan dengan aman berdasarkan prinsip BeyondCorp Google. IAP memverifikasi identitas pengguna dan konteks permintaan untuk menentukan apakah pengguna harus diizinkan untuk mengakses aplikasi atau resource. Integrasi IAP dengan Anthos Service Mesh memberikan manfaat berikut:

Selesaikan kontrol akses kontekstual ke beban kerja yang berjalan di Anthos Service Mesh. Anda dapat menetapkan kebijakan akses yang terperinci berdasarkan atribut permintaan asal, seperti identitas pengguna, alamat IP, dan jenis perangkat. Anda dapat menggabungkan kebijakan akses dengan pembatasan berdasarkan nama host dan jalur URL permintaan.
Aktifkan dukungan untuk klaim kontekstual dalam otorisasi Anthos Service Mesh.
Akses yang skalabel, aman, dan sangat tersedia ke aplikasi Anda melalui load balancer Google Cloud. Load balancing berperforma tinggi memberikan perlindungan bawaan untuk serangan distributed denial of service (DDoS) dan dukungan untuk pengalamatan IP anycast global.

Prasyarat

Ikuti langkah-langkah dalam Menginstal alat dependen dan memvalidasi cluster untuk:

Selain itu, panduan ini mengasumsikan bahwa Anda telah:

Menyiapkan cluster dengan Anthos Service Mesh

Bagian ini menjelaskan cara menyiapkan integrasi IAP untuk penginstalan baru Anthos Service Mesh dan upgrade.

Penginstalan baru

Aktifkan iap.googleapis.com. Dalam perintah berikut, ganti PROJECT_ID dengan project tempat Anda akan menginstal Anthos Service Mesh:
```
gcloud services enable \
  --project=PROJECT_ID \
  iap.googleapis.com
```
Cluster yang Anda update harus memiliki opsi --addons=HttpLoadBalancing yang ditetapkan. Add-on HttpLoadBalancing memungkinkan pengontrol load balancing HTTP (L7) untuk cluster. Jalankan perintah berikut untuk mengupdate cluster dengan opsi yang diperlukan oleh Anthos Service Mesh. Kecuali jika telah menetapkan zona atau region default, Anda harus menyediakan region (--region=REGION) atau zona (--zone=ZONE) dalam perintah.
```
gcloud container clusters update CLUSTER_NAME \
  --project=PROJECT_ID \
  --update-addons=HttpLoadBalancing=ENABLED
```
Secara default, file iap-operator.yaml memiliki port 31223 yang ditetapkan sebagai port status, dan port 31224 ditetapkan sebagai port http. Jika port 31223 sudah digunakan di cluster Anda, jalankan port berikut untuk menyetel port status lain:

Penting: Anda harus menggunakan kpt versi yang lebih lama dari v1.0.
```
kpt cfg set asm gcloud.container.cluster.ingress.statusPort STATUS_PORT
```
Jika port 31224 sudah digunakan di cluster Anda, jalankan perintah berikut untuk menyetel port http lain:
```
kpt cfg set asm gcloud.container.cluster.ingress.httpPort HTTP_PORT
```
Ikuti langkah-langkah di bagian Menginstal fitur default dan Mesh CA untuk menggunakan skrip yang disediakan Google guna menginstal Anthos Service Mesh. Saat Anda menjalankan skrip, sertakan opsi berikut:
```
--option iap-operator
```
Contoh:
```
./asmcli install \
  --project_id "PROJECT_ID" \
  --cluster_name "CLUSTER_NAME" \
  --cluster_location "CLUSTER_LOCATION" \
  --fleet_id FLEET_PROJECT_ID \
  --output_dir DIR_PATH \
  --enable_all \
  --option iap-operator
```
Saat Anda menginstal Anthos Service Mesh, file iap-operator.yaml menetapkan kolom type di layanan istio-ingressgateway ke NodePort, yang mengonfigurasi gateway untuk membuka port tertentu pada mesh layanan. Dengan begitu, Anda dapat menyiapkan load balancer, yang merutekan traffic yang dikirim ke nama domain Anda ke port ini.
Jika Anda menginstal Anthos Service Mesh terkelola, selesaikan juga langkah-langkah berikut:
1. Tambahkan label revisi ke namespace istio-system.
2. Download spesifikasi layanan gateway masuk Istio untuk IAP dan beri nama iap_operator.yaml.
3. Menginstal ingress sebagai layanan NodePort. Untuk mengetahui informasi selengkapnya, lihat Bermigrasi dari IstioOperator.
```
asmcli experimental mcp-migrate-check -f iap_operator.yaml

istioctl install -f /asm-generated-configs/gateways-istiooperator/"GATEWAY_NAME".yaml
```

Setelah menginstal Anthos Service Mesh, kembali ke panduan ini dan lanjutkan ke bagian berikutnya untuk menyiapkan integrasi dengan IAP.

Upgrade

Bagian ini membahas kasus penggunaan upgrade berikut:

Anda telah menyiapkan integrasi IAP dan sedang mengupgrade Anthos Service Mesh. Dalam hal ini, Anda telah mengaktifkan iap.googleapis.com di project dan add-on HttpLoadBalancing di cluster Anda. Lanjutkan ke langkah 3, untuk mendownload paket asm dan mengupgrade Anthos Service Mesh.
Anda akan mengupgrade Anthos Service Mesh dan ingin menyiapkan integrasi dengan IAP untuk pertama kalinya. Dalam hal ini, Anda harus menyelesaikan semua langkah berikut, mengupgrade Anthos Service Mesh, dan kembali ke panduan ini setelah upgrade untuk menyelesaikan integrasi.

Aktifkan iap.googleapis.com. Dalam perintah berikut, ganti PROJECT_ID dengan project tempat Anda akan menginstal Anthos Service Mesh.
```
gcloud services enable \
  --project=PROJECT_ID \
  iap.googleapis.com
```
Cluster yang Anda update harus memiliki opsi --addons=HttpLoadBalancing yang ditetapkan. Add-on HttpLoadBalancing memungkinkan pengontrol load balancing HTTP (L7) untuk cluster. Jalankan perintah berikut untuk mengupdate cluster dengan opsi yang diperlukan oleh Anthos Service Mesh. Kecuali jika telah menetapkan zona atau region default, Anda harus menyediakan region (--region=REGION) atau zona (--zone=ZONE) dalam perintah.
```
gcloud container clusters update CLUSTER_NAME \
  --project=PROJECT_ID
  --update-addons=HttpLoadBalancing=ENABLED
```

Jika Anda mengupdate Cloud Load Balancer HTTP yang sudah ada dan berfungsi, jalankan perintah berikut untuk mempertahankan port http dan status yang ada:

kpt cfg set asm gcloud.container.cluster.ingress.httpPort $(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="http2")].nodePort}')

kpt cfg set asm gcloud.container.cluster.ingress.statusPort $(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="status-port")].nodePort}')

Ikuti langkah-langkah di bagian Mengupgrade Anthos Service Mesh agar dapat menggunakan skrip yang disediakan Google untuk mengupgrade Anthos Service Mesh.

Saat Anda mengupgrade Anthos Service Mesh, file iap-operator.yaml akan menetapkan kolom type di layanan istio-ingressgateway ke NodePort, yang mengonfigurasi gateway untuk membuka port tertentu pada mesh layanan. Dengan begitu, Anda dapat menyiapkan load balancer, yang merutekan traffic yang dikirim ke nama domain Anda ke port ini.

Secara default, file iap-operator.yaml memiliki port 31223 yang ditetapkan sebagai port status, dan port 31224 ditetapkan sebagai port http.

Saat Anda menjalankan skrip, sertakan opsi berikut:
```
--option iap-operator
```
Contoh:
```
./asmcli install \
  --project_id "PROJECT_ID" \
  --cluster_name "CLUSTER_NAME" \
  --cluster_location "CLUSTER_LOCATION" \
  --fleet_id FLEET_PROJECT_ID \
  --output_dir DIR_PATH \
  --enable_all \
  --option iap-operator
```
Selesaikan upgrade dengan memicu injeksi proxy file bantuan otomatis pada beban kerja Anda. Untuk mengetahui detailnya, lihat Men-deploy dan men-deploy ulang workload.

Setelah menyelesaikan upgrade, kembali ke panduan ini dan lanjutkan ke bagian berikutnya untuk menyiapkan integrasi dengan IAP.

Mencadangkan alamat IP statis dan mengonfigurasi DNS

Untuk mengintegrasikan Identity-Aware Proxy dengan Anthos Service Mesh, Anda harus menyiapkan load balancer HTTP(S) Google Cloud, yang memerlukan nama domain yang mengarah ke alamat IP statis. Anda dapat memesan alamat IP eksternal statis, yang menetapkan alamat ke project Anda tanpa batas waktu hingga Anda melepaskannya secara eksplisit.

Mencadangkan alamat IP eksternal statis:

gcloud compute addresses create example-static-ip --global

Dapatkan alamat IP statis:

gcloud compute addresses describe example-static-ip --global

Di registrar nama domain, konfigurasikan nama domain yang sepenuhnya memenuhi syarat (FQDN) dengan alamat IP statis. Biasanya, Anda menambahkan data A ke setelan DNS. Langkah konfigurasi dan terminologi untuk menambahkan data A untuk FQDN bervariasi, bergantung pada registrar nama domain Anda.

Diperlukan waktu 24 hingga 48 jam agar setelan DNS diterapkan. Anda dapat melanjutkan penyiapan semuanya dalam panduan ini, tetapi Anda tidak akan dapat menguji penyiapan hingga setelan DNS diterapkan.

Men-deploy aplikasi contoh

Sebelum mengaktifkan IAP, Anda memerlukan aplikasi yang berjalan di cluster GKE agar dapat memverifikasi bahwa semua permintaan memiliki identitas. Panduan ini menggunakan contoh Bookinfo untuk menunjukkan cara menyiapkan load balancer HTTP(S) dan mengaktifkan IAP.

Ikuti langkah-langkah untuk men-deploy Bookinfo. Sebelum Anda men-deploy load balancer, aplikasi Bookinfo tidak dapat diakses di luar cluster GKE Anda (seperti dari browser).

Permintaan eksternal

Resource Gateway Bookinfo (ditentukan dalam samples/bookinfo/networking/bookinfo-gateway.yaml) menggunakan istio-ingressgateway yang telah dikonfigurasi sebelumnya. Ingat bahwa saat men-deploy Anthos Service Mesh, Anda menentukan NodePort untuk istio-ingressgateway, yang akan membuka port tertentu di mesh layanan. Meskipun node di cluster Anda memiliki alamat IP eksternal, permintaan yang berasal dari luar cluster Anda akan diblokir oleh aturan firewall Google Cloud. Dengan IAP, cara yang benar untuk mengekspos aplikasi ke internet publik adalah dengan menggunakan load balancer. Jangan mengekspos alamat node menggunakan aturan firewall, yang akan melewati IAP.

Untuk mengarahkan permintaan ke Bookinfo, siapkan load balancer HTTP(S) di project Google Cloud. Karena ada dalam project Anda, load balancer berada di dalam firewall dan dapat mengakses node di cluster Anda. Setelah mengonfigurasi load balancer dengan alamat IP statis dan nama domain, Anda dapat mengirim permintaan ke nama domain, dan load balancer meneruskan permintaan tersebut ke node dalam cluster.

Mengaktifkan IAP

Langkah-langkah berikut menjelaskan cara mengaktifkan IAP.

Mengonfigurasi layar izin

Periksa apakah Anda sudah memiliki merek dengan menggunakan perintah list. Anda mungkin hanya memiliki satu merek per proyek.
```
gcloud iap oauth-brands list
```
Berikut adalah contoh respons gcloud, jika brand ada:
```
name: projects/[PROJECT_NUMBER]/brands/[BRAND_ID]
applicationTitle: [APPLICATION_TITLE]
supportEmail: [SUPPORT_EMAIL]
orgInternalOnly: true
```
Catatan: Jika brand sudah ada untuk suatu project dan telah dikonfigurasi untuk pengguna eksternal (orgInternalOnly: false), tetapi Anda ingin membatasinya bagi pengguna internal, Anda harus membuat perubahan tersebut secara manual dari layar izin OAuth untuk membuat klien OAuth dengan API ini.
Jika tidak ada merek, gunakan perintah create:
```
gcloud iap oauth-brands create --application_title=APPLICATION_TITLE --support_email=SUPPORT_EMAIL
```
Kolom di atas wajib diisi saat memanggil API ini:
- supportEmail: Email dukungan yang ditampilkan di layar izin OAuth. Alamat email ini dapat berupa alamat pengguna atau alias Google Grup. Meskipun akun layanan juga memiliki alamat email, akun tersebut bukanlah alamat email valid yang sebenarnya, dan tidak dapat digunakan saat membuat merek. Namun, akun layanan dapat menjadi pemilik Google Grup. Buat Google Grup baru atau konfigurasi grup yang ada dan tetapkan akun layanan yang diinginkan sebagai pemilik grup.
  
  Catatan: Pengguna yang mengajukan permintaan harus merupakan pemilik alamat email dukungan yang ditentukan.
- applicationTitle: Nama aplikasi yang ditampilkan di layar izin OAuth.
Respons berisi kolom berikut:
```
name: projects/[PROJECT_NUMBER]/brands/[BRAND_ID]
applicationTitle: [APPLICATION_TITLE]
supportEmail: [SUPPORT_EMAIL]
orgInternalOnly: true
```

Membuat Klien OAuth IAP

Gunakan perintah create untuk membuat klien. Gunakan merek name dari langkah sebelumnya.

gcloud iap oauth-clients create projects/PROJECT_NUMBER/brands/BRAND-ID --display_name=NAME

Respons berisi kolom berikut:

name: projects/[PROJECT_NUMBER]/brands/[BRAND_NAME]/identityAwareProxyClients/[CLIENT_ID]
secret: [CLIENT_SECRET]
displayName: [NAME]

Gunakan client ID (CLIENT_ID pada langkah di atas) dan CLIENT_SECRET untuk mengaktifkan IAP. Buat rahasia kubernetes dengan materi dari Klien OAuth Anda:
```
kubectl create secret generic -n istio-system my-secret --from-literal=client_id=CLIENT_ID \
--from-literal=client_secret=CLIENT_SECRET
```

Men-deploy load balancer

Anda dapat menggunakan resource Ingress untuk membuat load balancer HTTP(S) dengan sertifikat SSL yang dikonfigurasi secara otomatis. Sertifikat SSL terkelola disediakan, diperpanjang, dan dikelola untuk domain Anda.

Membuat resource ManagedCertificate. Resource ini menentukan domain untuk sertifikat SSL. Daftar spec.domains hanya boleh berisi satu domain. Domain karakter pengganti tidak didukung. Pada YAML berikut, ganti DOMAIN_NAME dengan nama domain yang Anda konfigurasikan untuk alamat IP statis eksternal.
```
cat <<EOF | kubectl apply -f -
apiVersion: networking.gke.io/v1
kind: ManagedCertificate
metadata:
  name: example-certificate
  namespace: istio-system
spec:
  domains:
    - DOMAIN_NAME
EOF
```

Buat resource BackendConfig. Referensi ini menginstruksikan GCLB cara melakukan Health Check di Gateway Ingress, serta mengonfigurasi Identity-Aware Proxy. Pertama, kumpulkan beberapa nilai dari Gateway Ingress tentang health check:

Health check ingress port: Ini adalah port health check istio-ingress.

export HC_INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="status-port")].nodePort}')

Jalur masuk health check: Ini adalah jalur health check istio-ingress.

export HC_INGRESS_PATH=$(kubectl get pods -n istio-system -l app=istio-ingressgateway -o jsonpath='{.items[0].spec.containers[?(@.name=="istio-proxy")].readinessProbe.httpGet.path}')

cat <<EOF | kubectl apply -n istio-system -f -
apiVersion: cloud.google.com/v1
kind: BackendConfig
metadata:
  name: http-hc-config
spec:
  healthCheck:
    checkIntervalSec: 2
    timeoutSec: 1
    healthyThreshold: 1
    unhealthyThreshold: 10
    port: ${HC_INGRESS_PORT}
    type: HTTP
    requestPath: ${HC_INGRESS_PATH}
  iap:
    enabled: true
    oauthclientCredentials:
      secretName: my-secret
EOF

Anotasikan layanan masuk dengan BackendConfig.

    kubectl annotate -n istio-system service/istio-ingressgateway --overwrite \
      cloud.google.com/backend-config='{"default": "http-hc-config"}' \
      cloud.google.com/neg='{"ingress":false}'

Buat load balancer dengan menentukan resource Ingress.
- Setel anotasi networking.gke.io/managed-certificates ke nama sertifikat yang Anda buat di langkah sebelumnya, example-certificate.
- Setel anotasi kubernetes.io/ingress.global-static-ip-name ke nama alamat IP statis yang Anda cadangkan, example-static-ip.
- Tetapkan serviceName ke istio-ingressgateway, yang digunakan dalam resource Gateway untuk contoh Bookinfo.
```
cat <<EOF | kubectl apply -f -
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
  namespace: istio-system
  annotations:
    kubernetes.io/ingress.global-static-ip-name: example-static-ip
    networking.gke.io/managed-certificates: example-certificate
spec:
  defaultBackend:
    service:
      name: istio-ingressgateway
      port:
        number: 80
EOF
```
Catatan: Diperlukan waktu hingga 10-20 menit agar load balancer berfungsi.
Di konsol Google Cloud, buka halaman Kubernetes Engine > Services & Ingress.

Buka halaman Services & Ingress

Anda akan melihat pesan "Membuat ingress" di kolom Status. Tunggu hingga GKE menyediakan Ingress sepenuhnya sebelum melanjutkan. Muat ulang halaman setiap beberapa menit untuk mendapatkan status terbaru di Ingress. Setelah Ingress disediakan, Anda mungkin melihat status "Ok" atau error "All backend services are in UNHEALTHY state". Salah satu resource yang disediakan GKE adalah health check default. Jika Anda melihat pesan error, itu menunjukkan bahwa Ingress disediakan dan health check default berjalan. Jika Anda melihat status "Ok" atau error, lanjutkan ke bagian berikutnya untuk mengonfigurasi health check untuk load balancer.

Mengonfigurasi daftar akses IAP

Tambahkan pengguna ke kebijakan akses untuk IAP:

gcloud beta iap web add-iam-policy-binding \
    --member=user:EMAIL_ADDRESS \
    --role=roles/iap.httpsResourceAccessor

dengan EMAIL_ADDRESS adalah alamat email lengkap pengguna, seperti alice@example.com.

Menguji load balancer. Arahkan browser ke:
```
http://DOMAIN_NAME/productpage
```
dengan DOMAIN_NAME adalah nama domain yang Anda konfigurasi dengan alamat IP statis eksternal.

Anda akan melihat productpage aplikasi Bookinfo. Jika memuat ulang halaman beberapa kali, Anda akan melihat berbagai versi ulasan, yang ditampilkan dengan gaya round robin: bintang merah, bintang hitam, tanpa bintang.

Anda juga harus menguji akses https ke Bookinfo.

Mengaktifkan dukungan RCToken pada mesh layanan

Secara default, IAP menghasilkan Token Web JSON (JWT) yang dicakupkan ke klien OAuth. Untuk Anthos Service Mesh, Anda dapat mengonfigurasi IAP untuk menghasilkan RequestContextToken (RCToken), yang merupakan JWT, tetapi dengan audience yang dapat dikonfigurasi. Dengan RCToken, Anda dapat mengonfigurasi audience JWT ke string arbitrer, yang dapat digunakan dalam kebijakan Anthos Service Mesh untuk otorisasi terperinci.

Untuk mengonfigurasi RCToken:

Membuat variabel lingkungan untuk audience RCToken. String ini dapat berupa string apa pun yang Anda inginkan.
```
export RCTOKEN_AUD="your-rctoken-aud"
```
Opsional: Langkah berikut memerlukan BACKEND_SERVICE_ID. Jika Anda perlu mengetahui BACKEND_SERVICE_ID, jalankan perintah berikut:
```
kubectl -n istio-system get Ingress example-ingress -o json | jq \
 '.metadata.annotations."ingress.kubernetes.io/backends"'
```
Output yang diharapkan akan mirip dengan "{\"BACKEND_SERVICE_ID\":\"HEALTHY\"}". Misalnya, "ingress.kubernetes.io/backends": "{\"k8s-be-31224--51f3b55cd1457fb6\":\"HEALTHY\"}". BACKEND_SERVICE_ID dalam contoh ini adalah k8s-be-31224--51f3b55cd1457fb6.

Ambil setelan IAP yang ada.

gcloud iap settings get --format json \
--project=${PROJECT_ID} --resource-type=compute --service=BACKEND_SERVICE_ID > iapSettings.json

Mengupdate IapSettings dengan audiens RCToken.

cat iapSettings.json | jq --arg RCTOKEN_AUD_STR $RCTOKEN_AUD \
'. + {applicationSettings: {csmSettings: {rctokenAud: $RCTOKEN_AUD_STR}}}' \
> updatedIapSettings.json

gcloud iap settings set updatedIapSettings.json --format json \
--project=${PROJECT_ID} --resource-type=compute --service=BACKEND_SERVICE_ID

Mengaktifkan autentikasi RCToken di gateway ingress Istio.

cat <<EOF | kubectl apply -f -
apiVersion: "security.istio.io/v1beta1"
kind: "RequestAuthentication"
metadata:
  name: "ingressgateway-jwt-policy"
  namespace: "istio-system"
spec:
  selector:
    matchLabels:
      app: istio-ingressgateway
  jwtRules:
  - issuer: "https://cloud.google.com/iap"
    jwksUri: "https://www.gstatic.com/iap/verify/public_key-jwk"
    audiences:
    - $RCTOKEN_AUD
    fromHeaders:
    - name: ingress-authorization
      prefix: "Istio "
    outputPayloadToHeader: "verified-jwt"
    forwardOriginalToken: true
EOF

Opsional: Pastikan permintaan yang tidak memiliki JWT yang valid ditolak:

  cat <<EOF | kubectl apply -f -
  apiVersion: security.istio.io/v1beta1
  kind: AuthorizationPolicy
  metadata:
    name: iap-gateway-require-jwt
    namespace: istio-system
  spec:
    selector:
      matchLabels:
        app: istio-iap-ingressgateway
    action: DENY
    rules:
      - from:
          - source:
              notRequestPrincipals: ["*"]
  EOF

Pastikan permintaan ke productpage Bookinfo masih berhasil:
```
http://DOMAIN_NAME/productpage
```

Untuk menguji kebijakan:

Buat objek permintaan IapSettings, tetapi tetapkan rctokenAud ke string yang berbeda:

cat iapSettings.json | jq --arg RCTOKEN_AUD_STR wrong-rctoken-aud \
'. + {applicationSettings: {csmSettings: {rctokenAud: $RCTOKEN_AUD_STR}}}' \
> wrongIapSettings.json

Panggil IapSettings API untuk menetapkan audiens RCtoken.

gcloud beta iap settings set wrongIapSettings.json --project=PROJECT_ID --resource-type=compute --service=BACKEND_SERVICE

Buat permintaan ke productpage Bookinfo dan permintaan tersebut akan gagal:
```
http://DOMAIN_NAME/productpage
```

Pembersihan

Setelah menyelesaikan tutorial ini, hapus referensi berikut untuk mencegah timbulnya tagihan yang tidak diinginkan pada akun Anda:

Hapus sertifikat yang dikelola:

kubectl delete managedcertificates example-certificate

Hapus Ingress, yang membatalkan alokasi resource load balancing:
```
kubectl -n istio-system delete ingress example-ingress
```
Hapus alamat IP statis:
```
gcloud compute addresses delete example-static-ip --global
```
Jika Anda melakukannya, pastikan untuk menghapus alamat IP dari registrar domain.
Hapus cluster, yang akan menghapus resource yang membentuk cluster, seperti instance komputasi, disk, dan resource jaringan:
```
gcloud container clusters delete CLUSTER_NAME
```