Deploy Blue-Green dan Release Bertahap melalui Nginx Ingress - ACK

Saat memperbarui layanan, Anda dapat menggunakan metode rilis seperti peningkatan bergulir (rolling upgrades), penyebaran biru-hijau, dan rilis bertahap. Topik ini menjelaskan cara menggunakan Nginx Ingress Controller di kluster Container Service for Kubernetes (ACK) untuk mengimplementasikan rilis bertahap pada aplikasi.

Informasi latar belakang

Rilis bertahap dan penyebaran biru-hijau melibatkan pembuatan lingkungan produksi baru yang identik dengan yang sudah ada. Berdasarkan aturan tertentu, traffic secara bertahap diarahkan ke versi baru tanpa memengaruhi versi lama. Setelah versi baru stabil, seluruh traffic dialihkan ke versi tersebut.

Penyebaran biru-hijau merupakan jenis rilis bertahap. Sebagian pengguna tetap menggunakan versi lama layanan, sementara traffic dari pengguna lain dialihkan ke versi baru. Jika versi baru stabil, semua pengguna secara bertahap dialihkan ke versi tersebut.

Fitur rilis bertahap di Konsol ACK mendukung dua metode.

Metode anotasi canary-*: Anda dapat menggunakan anotasi canary-* untuk mengonfigurasi penyebaran biru-hijau dan rilis bertahap. Anotasi canary-* merupakan metode resmi komunitas untuk menerapkan rilis bertahap.
Metode anotasi service-* (tidak digunakan lagi): Anotasi service-* merupakan metode awal yang digunakan oleh ACK Nginx Ingress Controller untuk mengimplementasikan rilis bertahap.

Penting

Anotasi service-* tidak tersedia lagi di Nginx Ingress Controller v1.12 dan versi setelahnya. Jangan menggunakannya.

Skenario

Pemisahan traffic berdasarkan permintaan klien

Misalkan Anda memiliki layanan, Service A, yang menyediakan layanan Lapisan 7 di lingkungan online. Anda ingin merilis versi baru, Service A', dengan fitur-fitur baru. Alih-alih langsung mengganti Service A, Anda dapat meneruskan permintaan ke Service A' hanya jika header permintaan berisi foo=bar atau cookie berisi foo=bar. Setelah Service A' berjalan stabil, Anda dapat mengalihkan seluruh traffic dari Service A ke Service A' lalu menonaktifkan Service A.

Pemisahan traffic berdasarkan bobot layanan

Misalkan Anda memiliki layanan, Service B, yang menyediakan layanan Lapisan 7 di lingkungan online. Anda telah memperbaiki beberapa masalah dan perlu merilis versi baru, Service B'. Alih-alih mengalihkan seluruh traffic klien ke versi baru sekaligus, Anda ingin mengalihkan 20% traffic ke Service B'. Setelah Service B' stabil, Anda dapat mengalihkan seluruh traffic dari Service B ke Service B' lalu menonaktifkan Service B.

Untuk memenuhi persyaratan rilis aplikasi ini, Alibaba Cloud Container Service Ingress Controller mendukung metode pemisahan traffic berikut:

Pemisahan traffic berdasarkan header permintaan, cocok untuk skenario rilis bertahap dan Pengujian A/B.
Pemisahan traffic berdasarkan cookie, cocok untuk skenario rilis bertahap dan Pengujian A/B.
Pemisahan traffic berdasarkan parameter kueri, cocok untuk skenario rilis bertahap dan Pengujian A/B.
Pemisahan traffic berdasarkan bobot layanan, cocok untuk skenario penyebaran biru-hijau.

Metode anotasi canary-*

Deskripsi anotasi

Nginx Ingress Controller menggunakan anotasi canary-* berikut untuk mendukung rilis bertahap aplikasi.

Anotasi	Deskripsi	Versi ACK Nginx Ingress Controller yang didukung
nginx.ingress.kubernetes.io/canary	Atur anotasi ini ke `true`. Jika tidak, aturan lain tidak berlaku. Nilai yang valid: `true`: Mengaktifkan fitur `canary`. `false`: Menonaktifkan fitur `canary`.	≥v0.22.0
nginx.ingress.kubernetes.io/canary-by-header	Menentukan rilis bertahap berdasarkan header permintaan. Nilai khusus untuk header permintaan: `always`: Traffic selalu diarahkan ke layanan canary. `never`: Traffic tidak pernah diarahkan ke layanan canary. Jika Anda tidak menentukan nilai untuk header permintaan, traffic diteruskan selama header tersebut ada.	≥v0.22.0
nginx.ingress.kubernetes.io/canary-by-header-value	Menentukan rilis bertahap berdasarkan nilai header permintaan. Harus digunakan bersama anotasi `canary-by-header`.	≥v0.30.0
nginx.ingress.kubernetes.io/canary-by-header-pattern	Menentukan rilis bertahap berdasarkan nilai header permintaan, menggunakan ekspresi reguler untuk pencocokan. Harus digunakan bersama anotasi `canary-by-header`. Nilainya adalah ekspresi reguler yang digunakan untuk mencocokkan nilai header permintaan.	≥v0.44.0
nginx.ingress.kubernetes.io/canary-by-cookie	Menentukan rilis bertahap berdasarkan cookie. Contoh: `nginx.ingress.kubernetes.io/canary-by-cookie: foo`. Nilai cookie: `always`: Saat `foo=always`, traffic diarahkan ke layanan canary. `never`: Saat `foo=never`, traffic tidak diarahkan ke layanan canary. Traffic diteruskan hanya jika cookie ada dan nilainya `always`.	≥v0.22.0
nginx.ingress.kubernetes.io/canary-weight	Menentukan rilis bertahap berdasarkan bobot. Nilainya berkisar dari 0 hingga total bobot. Jika total bobot tidak ditetapkan, nilai default-nya adalah 100.	≥v0.22.0
nginx.ingress.kubernetes.io/canary-weight-total	Menentukan nilai total bobot. Jika nilai total tidak ditetapkan, nilai default-nya adalah 100.	≥v1.1.2

Prioritas berbagai metode grayscale diurutkan dari yang tertinggi ke terendah:

canary-by-header > canary-by-cookie > canary-weight

Catatan

Setiap aturan Ingress hanya mendukung satu Canary Ingress dalam satu waktu. Canary Ingress tambahan akan diabaikan.

Langkah 1: Menerapkan layanan

Deploy layanan Nginx dan sediakan akses nama domain Lapisan 7 melalui Nginx Ingress Controller.

Buat Deployment dan Service.

Buat file nginx.yaml.

Lihat file YAML

apiVersion: apps/v1
kind: Deployment
metadata:
  name: old-nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      run: old-nginx
  template:
    metadata:
      labels:
        run: old-nginx
    spec:
      containers:
      - image: registry.cn-hangzhou.aliyuncs.com/acs-sample/old-nginx
        imagePullPolicy: Always
        name: old-nginx
        ports:
        - containerPort: 80
          protocol: TCP
      restartPolicy: Always
---
apiVersion: v1
kind: Service
metadata:
  name: old-nginx
spec:
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    run: old-nginx
  sessionAffinity: None
  type: NodePort

Jalankan perintah berikut untuk membuat Deployment dan Service.
```
kubectl apply -f nginx.yaml
```

Deploy Ingress.

Buat file ingress.yaml.

Untuk kluster v1.19 dan versi setelahnya

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: gray-release
spec:
  ingressClassName: nginx
  rules:
  - host: www.example.com
    http:
      paths:
      # Versi lama layanan.
      - path: /
        backend:
          service: 
            name: old-nginx
            port:
              number: 80
        pathType: ImplementationSpecific

Untuk kluster sebelum v1.19

apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: gray-release
spec:
  rules:
  - host: www.example.com
    http:
      paths:
      # Versi lama layanan.
      - path: /
        backend:
          serviceName: old-nginx
          servicePort: 80

Jalankan perintah berikut untuk deploy Ingress.
```
kubectl apply -f ingress.yaml
```

Uji akses.
1. Jalankan perintah berikut untuk mengambil alamat IP eksternal.
```
kubectl get ingress
```
2. Jalankan perintah berikut untuk memeriksa akses routing.
```
curl -H "Host: www.example.com"  http://<EXTERNAL_IP>
```
  Output yang diharapkan:
```
old
```

Langkah 2: Lakukan rilis bertahap versi layanan baru

Rilis versi baru layanan Nginx dan konfigurasikan aturan routing.

Deploy versi baru Deployment dan Service.

Buat file nginx1.yaml.

Lihat file YAML

apiVersion: apps/v1
kind: Deployment
metadata:
  name: new-nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      run: new-nginx
  template:
    metadata:
      labels:
        run: new-nginx
    spec:
      containers:
      - image: registry.cn-hangzhou.aliyuncs.com/acs-sample/new-nginx
        imagePullPolicy: Always
        name: new-nginx
        ports:
        - containerPort: 80
          protocol: TCP
      restartPolicy: Always
---
apiVersion: v1
kind: Service
metadata:
  name: new-nginx
spec:
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    run: new-nginx
  sessionAffinity: None
  type: NodePort

Jalankan perintah berikut untuk deploy Deployment dan Service yang diperbarui.
```
kubectl apply -f nginx1.yaml
```

Tetapkan aturan routing untuk mengakses versi layanan baru.

ACK mendukung tiga jenis aturan routing berikut. Pilih salah satu yang sesuai dengan kebutuhan Anda.

Izinkan akses ke versi layanan baru hanya untuk klien yang memenuhi aturan tertentu. Contoh berikut mengarahkan permintaan ke versi layanan baru hanya jika header permintaan berisi foo=bar.

Berdasarkan kondisi di atas, buat resource Ingress baru bernama gray-release-canary dalam file ingress1.yaml.

Untuk kluster v1.19 dan versi setelahnya

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: gray-release-canary
  annotations:
    # Aktifkan Canary.
    nginx.ingress.kubernetes.io/canary: "true"
    # Header permintaan adalah foo.
    nginx.ingress.kubernetes.io/canary-by-header: "foo"
    # Permintaan diarahkan ke versi layanan baru new-nginx hanya ketika nilai header foo adalah bar.
    nginx.ingress.kubernetes.io/canary-by-header-value: "bar"
    
spec:
  ingressClassName: nginx
  rules:
  - host: www.example.com
    http:
      paths:
      # Versi baru layanan.
      - path: /
        backend:
          service: 
            name: new-nginx
            port:
              number: 80
        pathType: ImplementationSpecific

Untuk kluster sebelum v1.19

apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: gray-release-canary
  annotations:
    # Aktifkan Canary.
    nginx.ingress.kubernetes.io/canary: "true"
    # Header permintaan adalah foo.
    nginx.ingress.kubernetes.io/canary-by-header: "foo"
    # Permintaan diarahkan ke versi layanan baru new-nginx hanya ketika nilai header foo adalah bar.
    nginx.ingress.kubernetes.io/canary-by-header-value: "bar"
spec:
  rules:
  - host: www.example.com
    http:
      paths:
      # Versi baru layanan.
      - path: /
        backend:
          serviceName: new-nginx
          servicePort: 80

Jalankan perintah berikut untuk deploy Ingress.
```
kubectl apply -f ingress1.yaml
```
Jalankan perintah berikut untuk mendapatkan alamat IP eksternal.
```
kubectl get ingress
```
Verifikasi akses routing.
1. Jalankan perintah berikut untuk mengakses layanan.
```
curl -H "Host: www.example.com"  http://<EXTERNAL_IP>
```
  Output yang diharapkan:
```
old
```
2. Jalankan perintah berikut untuk mengakses layanan dengan permintaan klien yang header-nya berisi foo=bar.
```
curl -H "Host: www.example.com" -H "foo: bar" http://<EXTERNAL_IP>
```
  Output yang diharapkan:
```
new
```
Jalankan perintah lagi. Output menunjukkan bahwa hanya permintaan klien dengan header foo=bar yang diarahkan ke versi layanan baru.

Arahkan persentase traffic ke versi aplikasi baru untuk permintaan yang tidak sesuai aturan tertentu. Misalnya, jika permintaan tidak berisi header foo=bar yang diperlukan, Anda dapat mengarahkan 50% traffic ke versi aplikasi baru.

Ubah Ingress yang dibuat pada langkah 2 dengan konten berikut.

Untuk kluster v1.19 dan versi setelahnya

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: gray-release-canary
  annotations:
    # Aktifkan Canary.
    nginx.ingress.kubernetes.io/canary: "true"
    # Header permintaan adalah foo.
    nginx.ingress.kubernetes.io/canary-by-header: "foo"
    # Permintaan diarahkan ke versi layanan baru new-nginx hanya ketika nilai header foo adalah bar.
    nginx.ingress.kubernetes.io/canary-by-header-value: "bar"
    # Jika aturan di atas tidak terpenuhi, 50% traffic diarahkan ke versi layanan baru new-nginx.
    nginx.ingress.kubernetes.io/canary-weight: "50"
spec:
  ingressClassName: nginx
  rules:
  - host: www.example.com
    http:
      paths:
      # Versi baru layanan.
      - path: /
        backend:
          service: 
            name: new-nginx
            port:
              number: 80
        pathType: ImplementationSpecific

Untuk kluster sebelum v1.19

apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: gray-release-canary
  annotations:
    # Aktifkan Canary.
    nginx.ingress.kubernetes.io/canary: "true"
    # Header permintaan adalah foo.
    nginx.ingress.kubernetes.io/canary-by-header: "foo"
    # Permintaan diarahkan ke versi layanan baru new-nginx hanya ketika nilai header foo adalah bar.
    nginx.ingress.kubernetes.io/canary-by-header-value: "bar"
    # Jika aturan di atas tidak terpenuhi, 50% traffic diarahkan ke versi layanan baru new-nginx.
    nginx.ingress.kubernetes.io/canary-weight: "50"
spec:
  rules:
  - host: www.example.com
    http:
      paths:
      # Versi baru layanan.
      - path: /
        backend:
          serviceName: new-nginx
          servicePort: 80

Jalankan perintah berikut untuk deploy Ingress.
```
kubectl apply -f ingress.yaml
```
Jalankan perintah berikut untuk mendapatkan alamat IP eksternal.
```
kubectl get ingress
```
Verifikasi akses routing.
1. Jalankan perintah berikut untuk mengakses layanan.
```
curl -H "Host: www.example.com"  http://<EXTERNAL_IP>
```
  Output yang diharapkan:
```
old
```
2. Jalankan perintah berikut untuk mengakses layanan dengan permintaan klien yang header-nya berisi foo=bar.
```
curl -H "Host: www.example.com" -H "foo: bar" http://<EXTERNAL_IP>
```
  Output yang diharapkan:
```
new
```
- Dengan header permintaan foo=bar:
  100% traffic diarahkan ke layanan new-nginx yang baru. Ini dikontrol oleh canary-by-header dan canary-by-header-value.
- Tanpa header permintaan foo=bar:
  50% traffic diarahkan ke layanan new-nginx yang baru. Ini dikontrol oleh canary-weight.

Arahkan persentase tertentu permintaan ke versi layanan baru. Pada contoh berikut, 50% traffic diarahkan ke versi layanan baru.

Ubah Ingress yang dibuat pada langkah 2 dengan konten berikut.

Untuk kluster v1.19 dan versi setelahnya

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: gray-release-canary
  annotations:
    # Aktifkan Canary.
    nginx.ingress.kubernetes.io/canary: "true"
    # Arahkan 50% traffic ke versi layanan baru new-nginx.
    # Nilai total default adalah 100.
    nginx.ingress.kubernetes.io/canary-weight: "50"
spec:
  ingressClassName: nginx
  rules:
  - host: www.example.com
    http:
      paths:
      # Versi baru layanan.
      - path: /
        backend:
          service: 
            name: new-nginx
            port:
              number: 80
        pathType: ImplementationSpecific

Untuk kluster sebelum v1.19

apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: gray-release-canary
  annotations:
    # Aktifkan Canary.
    nginx.ingress.kubernetes.io/canary: "true"
    # Arahkan 50% traffic ke versi layanan baru new-nginx.
    # Nilai total default adalah 100.
    nginx.ingress.kubernetes.io/canary-weight: "50"
spec:
  rules:
  - host: www.example.com
    http:
      paths:
      # Versi baru layanan.
      - path: /
        backend:
          serviceName: new-nginx
          servicePort: 80

Jalankan perintah berikut untuk deploy Ingress.
```
kubectl apply -f ingress.yaml
```
Jalankan perintah berikut untuk mendapatkan alamat IP eksternal.
```
kubectl get ingress
```
Jalankan perintah berikut untuk memverifikasi akses routing.
```
curl -H "Host: www.example.com" http://<EXTERNAL_IP>
```

Jalankan perintah lagi. Output menunjukkan bahwa 50% traffic diarahkan ke versi layanan baru.

Langkah 3: Hapus versi layanan lama

Setelah Anda memverifikasi bahwa versi layanan baru stabil dan sesuai harapan, Anda dapat menonaktifkan versi layanan lama sehingga hanya versi baru yang berjalan. Untuk melakukannya, arahkan Service lama ke Deployment versi baru, lalu hapus Deployment lama dan Service baru.

Ubah file Service lama, nginx.yaml, agar mengarah ke layanan baru.

Lihat file YAML

apiVersion: v1
kind: Service
metadata:
  name: old-nginx
spec:
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    # Arahkan ke versi layanan baru.
    run: new-nginx
  sessionAffinity: None
  type: NodePort

Jalankan perintah berikut untuk deploy versi lama layanan.
```
kubectl apply -f nginx.yaml
```
Jalankan perintah berikut untuk mendapatkan alamat IP eksternal.
```
kubectl get ingress
```
Jalankan perintah berikut untuk memeriksa routing.
```
curl -H "Host: www.example.com" http://<EXTERNAL_IP>
```
Output yang diharapkan:
```
new
```
Jalankan perintah lagi. Anda dapat melihat bahwa semua permintaan diarahkan ke versi layanan baru.
Jalankan perintah berikut untuk menghapus resource Canary Ingress gray-release-canary.
```
kubectl delete ingress gray-release-canary
```
Hapus Deployment lama dan Service baru.
1. Jalankan perintah berikut untuk menghapus Deployment lama.
```
kubectl delete deploy old-nginx
```
2. Jalankan perintah berikut untuk menghapus Service baru.
```
kubectl delete svc new-nginx
```

Metode anotasi service-*

Penting

Anotasi service-* tidak tersedia lagi di Nginx Ingress Controller v1.12 dan versi setelahnya. Jangan menggunakannya.

Deskripsi anotasi

Nginx Ingress Controller menggunakan anotasi berikut untuk mendukung rilis bertahap layanan aplikasi.

nginx.ingress.kubernetes.io/service-match

Anotasi ini mengonfigurasi aturan routing untuk versi layanan baru.

nginx.ingress.kubernetes.io/service-match: | 
    <service-name>: <match-rule>
# Deskripsi metrik:
# service-name: Nama layanan. Permintaan yang sesuai match-rule diarahkan ke layanan ini.
# match-rule: Aturan routing.
#
# Aturan routing:
# 1. Jenis pencocokan yang didukung
# - header: Berdasarkan header permintaan. Mendukung Regex Match dan pencocokan eksak.
# - cookie: Berdasarkan cookie. Mendukung Regex Match dan pencocokan eksak.
# - query: Berdasarkan parameter permintaan. Mendukung Regex Match dan pencocokan eksak.
#
# 2. Metode pencocokan
# - Format Regex Match: /{ekspresi reguler}/. Garis miring ganda (//) menunjukkan Regex Match.
# - Format pencocokan eksak: "{ekspresi eksak}". Tanda kutip ("") menunjukkan pencocokan eksak.

Contoh konfigurasi aturan routing:

# Permintaan yang header foo-nya cocok dengan ekspresi reguler ^bar$ diteruskan ke versi layanan baru new-nginx.
new-nginx: header("foo", /^bar$/)
# Permintaan yang header foo-nya merupakan pencocokan eksak dengan bar diteruskan ke versi layanan baru new-nginx.
new-nginx: header("foo", "bar")
# Permintaan yang cookie foo-nya cocok dengan ekspresi reguler ^sticky-.+$ diteruskan ke versi layanan baru new-nginx.
new-nginx: cookie("foo", /^sticky-.+$/)
# Permintaan yang parameter kueri foo-nya merupakan pencocokan eksak dengan bar diteruskan ke versi layanan baru new-nginx.
new-nginx: query("foo", "bar")

nginx.ingress.kubernetes.io/service-weight

Anotasi ini mengonfigurasi bobot traffic untuk versi layanan lama dan baru.

nginx.ingress.kubernetes.io/service-weight: | 
    <new-svc-name>:<new-svc-weight>, <old-svc-name>:<old-svc-weight>
Deskripsi metrik:
new-svc-name: Nama versi layanan baru.
new-svc-weight: Bobot versi layanan baru.
old-svc-name: Nama versi layanan lama.
old-svc-weight: Bobot versi layanan lama.

Contoh konfigurasi bobot layanan:

nginx.ingress.kubernetes.io/service-weight: | 
    new-nginx: 20, old-nginx: 60

Langkah 1: Deploy layanan

Deploy layanan Nginx dan sediakan akses nama domain Lapisan 7 menggunakan Nginx Ingress Controller.

Buat Deployment dan Service.

Buat file nginx.yaml.

Lihat file YAML

apiVersion: apps/v1
kind: Deployment
metadata:
  name: old-nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      run: old-nginx
  template:
    metadata:
      labels:
        run: old-nginx
    spec:
      containers:
      - image: registry.cn-hangzhou.aliyuncs.com/acs-sample/old-nginx
        imagePullPolicy: Always
        name: old-nginx
        ports:
        - containerPort: 80
          protocol: TCP
      restartPolicy: Always
---
apiVersion: v1
kind: Service
metadata:
  name: old-nginx
spec:
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    run: old-nginx
  sessionAffinity: None
  type: NodePort

Jalankan perintah berikut untuk membuat Deployment dan Service.
```
kubectl apply -f nginx.yaml
```

Deploy Ingress.

Buat file ingress.yaml.

Untuk kluster v1.19 dan versi setelahnya

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: gray-release
spec:
  ingressClassName: nginx
  rules:
  - host: www.example.com
    http:
      paths:
      # Versi lama layanan.
      - path: /
        backend:
          service: 
            name: old-nginx
            port:
              number: 80
        pathType: ImplementationSpecific

Untuk kluster sebelum v1.19

apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: gray-release
spec:
  rules:
  - host: www.example.com
    http:
      paths:
      # Versi lama layanan.
      - path: /
        backend:
          serviceName: old-nginx
          servicePort: 80

Jalankan perintah berikut untuk deploy Ingress.
```
kubectl apply -f ingress.yaml
```

Uji akses.
1. Jalankan perintah berikut untuk mengambil alamat IP eksternal.
```
kubectl get ingress
```
2. Jalankan perintah berikut untuk memeriksa akses routing.
```
curl -H "Host: www.example.com"  http://<EXTERNAL_IP>
```
  Output yang diharapkan:
```
old
```

Langkah 2: Lakukan rilis bertahap versi layanan baru

Deploy versi baru layanan Nginx dan konfigurasikan aturan routing.

Deploy versi baru Deployment dan Service.

Buat file nginx1.yaml.

Lihat file YAML

apiVersion: apps/v1
kind: Deployment
metadata:
  name: new-nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      run: new-nginx
  template:
    metadata:
      labels:
        run: new-nginx
    spec:
      containers:
      - image: registry.cn-hangzhou.aliyuncs.com/acs-sample/new-nginx
        imagePullPolicy: Always
        name: new-nginx
        ports:
        - containerPort: 80
          protocol: TCP
      restartPolicy: Always
---
apiVersion: v1
kind: Service
metadata:
  name: new-nginx
spec:
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    run: new-nginx
  sessionAffinity: None
  type: NodePort

Deploy versi baru Deployment dan Service.
```
kubectl apply -f nginx1.yaml
```

Tetapkan aturan routing untuk mengakses versi layanan baru.

ACK mendukung tiga jenis aturan routing berikut. Anda dapat memilih salah satu berdasarkan kebutuhan Anda.

Arahkan permintaan ke versi layanan baru hanya dari klien yang memenuhi aturan tertentu. Contoh berikut mengarahkan permintaan ke versi layanan baru hanya jika header permintaan berisi foo=bar.

Ubah Ingress yang Anda buat pada langkah 2 agar menggunakan konten berikut.

Untuk kluster v1.19 dan versi setelahnya

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: gray-release
  annotations:
    # Permintaan yang header foo-nya cocok dengan ekspresi reguler foo=bar diarahkan ke versi layanan baru new-nginx.
    nginx.ingress.kubernetes.io/service-match: | 
      new-nginx: header("foo", /^bar$/)
spec:
  ingressClassName: nginx
  rules:
  - host: www.example.com
    http:
      paths:
      # Versi lama layanan.
      - path: /
        backend:
          service: 
            name: old-nginx
            port:
              number: 80
        pathType: ImplementationSpecific
      # Versi baru layanan.
      - path: /
        backend:
          service: 
            name: new-nginx
            port:
              number: 80
        pathType: ImplementationSpecific

Untuk kluster sebelum v1.19

apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: gray-release
  annotations:
    # Permintaan yang header foo-nya cocok dengan ekspresi reguler foo=bar diarahkan ke versi layanan baru new-nginx.
    nginx.ingress.kubernetes.io/service-match: | 
      new-nginx: header("foo", /^bar$/)
spec:
  rules:
  - host: www.example.com
    http:
      paths:
      # Versi lama layanan.
      - path: /
        backend:
          serviceName: old-nginx
          servicePort: 80
      # Versi baru layanan.
      - path: /
        backend:
          serviceName: new-nginx
          servicePort: 80

Jalankan perintah berikut untuk deploy Ingress.
```
kubectl apply -f ingress.yaml
```
Jalankan perintah berikut untuk mengambil alamat IP eksternal.
```
kubectl get ingress
```
Periksa akses routing.
1. Jalankan perintah berikut untuk mengakses layanan.
```
curl -H "Host: www.example.com"  http://<EXTERNAL_IP>
```
  Output yang diharapkan:
```
old
```
2. Jalankan perintah berikut untuk mengakses layanan menggunakan permintaan klien yang header-nya berisi foo=bar.
```
curl -H "Host: www.example.com" -H "foo: bar" http://<EXTERNAL_IP>
```
  Output yang diharapkan:
```
new
```

Jalankan perintah lagi. Output menunjukkan bahwa hanya permintaan klien dengan header foo=bar yang diarahkan ke versi layanan baru.

Arahkan persentase permintaan yang memenuhi aturan tertentu ke versi layanan baru. Contoh berikut mengarahkan 50% traffic ke versi layanan baru untuk permintaan klien yang header-nya berisi foo=bar.

Ubah Ingress yang Anda buat pada langkah 2 agar menggunakan konten berikut.

Untuk kluster v1.19 dan versi setelahnya

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: gray-release
  annotations:
    # Permintaan yang header foo-nya cocok dengan ekspresi reguler foo=bar diarahkan ke versi layanan baru new-nginx.
    nginx.ingress.kubernetes.io/service-match: |
        new-nginx: header("foo", /^bar$/)
    # Berdasarkan aturan di atas, hanya 50% traffic yang diarahkan ke versi layanan baru new-nginx.
    nginx.ingress.kubernetes.io/service-weight: |
        new-nginx: 50, old-nginx: 50
spec:
  ingressClassName: nginx
  rules:
  - host: www.example.com
    http:
      paths:
      # Versi lama layanan.
      - path: /
        backend:
          service: 
            name: old-nginx
            port:
              number: 80
        pathType: ImplementationSpecific
      # Versi baru layanan.
      - path: /
        backend:
          service: 
            name: new-nginx
            port:
              number: 80
        pathType: ImplementationSpecific

Untuk kluster sebelum v1.19

apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: gray-release
  annotations:
    # Permintaan yang header foo-nya cocok dengan ekspresi reguler foo=bar diarahkan ke versi layanan baru new-nginx.
    nginx.ingress.kubernetes.io/service-match: |
        new-nginx: header("foo", /^bar$/)
    # Berdasarkan aturan di atas, hanya 50% traffic yang diarahkan ke versi layanan baru new-nginx.
    nginx.ingress.kubernetes.io/service-weight: |
        new-nginx: 50, old-nginx: 50
spec:
  rules:
  - host: www.example.com
    http:
      paths:
      # Versi lama layanan.
      - path: /
        backend:
          serviceName: old-nginx
          servicePort: 80
      # Versi baru layanan.
      - path: /
        backend:
          serviceName: new-nginx
          servicePort: 80

Jalankan perintah berikut untuk deploy Ingress.
```
kubectl apply -f ingress.yaml
```
Jalankan perintah berikut untuk mengambil alamat IP eksternal.
```
kubectl get ingress
```
Periksa akses routing.
1. Jalankan perintah berikut untuk mengakses layanan.
```
curl -H "Host: www.example.com"  http://<EXTERNAL_IP>
```
  Output yang diharapkan:
```
old
```
2. Jalankan perintah berikut untuk mengakses layanan menggunakan permintaan klien yang header-nya berisi foo=bar.
```
curl -H "Host: www.example.com" -H "foo: bar" http://<EXTERNAL_IP>
```
  Output yang diharapkan:
```
new
```
Jalankan perintah lagi. Output menunjukkan bahwa hanya 50% traffic dari permintaan klien dengan header foo=bar yang diarahkan ke versi layanan baru.

Arahkan persentase permintaan ke versi layanan baru. Pada contoh berikut, 50% traffic diarahkan ke versi layanan baru.

Ubah Ingress yang Anda buat pada langkah 2 agar menggunakan konten berikut.

Untuk kluster v1.19 dan versi setelahnya

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: gray-release
  annotations:
      # Arahkan 50% traffic ke versi layanan baru new-nginx.
      nginx.ingress.kubernetes.io/service-weight: |
          new-nginx: 50, old-nginx: 50
spec:
  ingressClassName: nginx
  rules:
  - host: www.example.com
    http:
      paths:
      # Versi lama layanan.
      - path: /
        backend:
          service: 
            name: old-nginx
            port:
              number: 80
        pathType: ImplementationSpecific
      # Versi baru layanan.
      - path: /
        backend:
          service: 
            name: new-nginx
            port:
              number: 80
        pathType: ImplementationSpecific

Untuk kluster sebelum v1.19

apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: gray-release
  annotations:
      # Arahkan 50% traffic ke versi layanan baru new-nginx.
      nginx.ingress.kubernetes.io/service-weight: |
          new-nginx: 50, old-nginx: 50
spec:
  rules:
  - host: www.example.com
    http:
      paths:
      # Versi lama layanan.
      - path: /
        backend:
          serviceName: old-nginx
          servicePort: 80
      # Versi baru layanan.
      - path: /
        backend:
          serviceName: new-nginx
          servicePort: 80

Jalankan perintah berikut untuk deploy Ingress.
```
kubectl apply -f ingress.yaml
```
Jalankan perintah berikut untuk mengambil alamat IP eksternal.
```
kubectl get ingress
```
Jalankan perintah berikut untuk memeriksa akses routing.
```
curl -H "Host: www.example.com" http://<EXTERNAL_IP>
```
Jalankan perintah lagi. Output menunjukkan bahwa 50% traffic diarahkan ke versi layanan baru.

Langkah 3: Hapus versi layanan lama

Setelah versi layanan baru berjalan stabil dalam periode tertentu dan memenuhi harapan Anda, Anda dapat menonaktifkan versi layanan lama sehingga hanya versi baru yang berjalan.

Ubah Ingress yang Anda buat pada langkah 2 agar menggunakan konten berikut.

Untuk kluster v1.19 dan versi setelahnya

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: gray-release
spec:
  ingressClassName: nginx
  rules:
  - host: www.example.com
    http:
      paths:
      # Versi baru layanan.
      - path: /
        backend:
          service: 
            name: new-nginx
            port:
              number: 80
        pathType: ImplementationSpecific

Untuk kluster sebelum v1.19

apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: gray-release
spec:
  rules:
  - host: www.example.com
    http:
      paths:
      # Versi baru layanan.
      - path: /
        backend:
          serviceName: new-nginx
          servicePort: 80

Jalankan perintah berikut untuk deploy Ingress.
```
kubectl apply -f ingress.yaml
```
Jalankan perintah berikut untuk mengambil alamat IP eksternal.
```
kubectl get ingress
```
Jalankan perintah berikut untuk memeriksa akses routing.
```
curl -H "Host: www.example.com" http://<EXTERNAL_IP>
```
Output yang diharapkan:
```
new
```
Jalankan perintah lagi. Output menunjukkan bahwa semua permintaan diarahkan ke versi layanan baru.
Hapus Deployment dan Service lama.
1. Jalankan perintah berikut untuk menghapus Deployment lama.
```
kubectl delete deploy <Deployment_name>
```
2. Jalankan perintah berikut untuk menghapus Service lama.
```
kubectl delete svc <Service_name>
```