Menyiapkan aplikasi untuk Cloud Service Mesh

Download kode contoh

1. Download kode sumber helloserver:

   git clone https://github.com/GoogleCloudPlatform/anthos-service-mesh-samples
   

2. Ubah ke direktori kode contoh:

   cd anthos-service-mesh-samples/docs/helloserver
   

Menjelajahi aplikasi multi-layanan

Aplikasi contoh ditulis dalam Python, dan memiliki dua komponen yang berkomunikasi menggunakan REST:

• server: Server sederhana dengan satu endpoint GET, / , yang mencetak "hello world" ke konsol.
• loadgen: Skrip yang mengirim traffic ke server, dengan jumlah permintaan per detik (RPS) yang dapat dikonfigurasi.

Menjalankan aplikasi dari sumber

Untuk memahami aplikasi contoh, jalankan di Cloud Shell.

1. Dari direktori sample-apps/helloserver, jalankan server:

   python3 server/server.py
   

   Saat startup, server menampilkan hal berikut:

   INFO:root:Starting server...
   

2. Buka jendela terminal lain agar Anda dapat mengirim permintaan ke server. Klik add untuk membuka sesi lain.

3. Kirim permintaan ke server:

   curl http://localhost:8080
   

   server merespons:

   Hello World!
   

4. Dari direktori tempat Anda mendownload kode contoh, ubah ke direktori yang berisi loadgen:

   cd YOUR_WORKING_DIRECTORY/anthos-service-mesh-samples/docs/helloserver/loadgen

5. Buat variabel lingkungan berikut:

   export SERVER_ADDR=http://localhost:8080
   export REQUESTS_PER_SECOND=5
   

6. Mulai virtualenv:

   virtualenv --python python3 env
   

7. Aktifkan lingkungan virtual:

   source env/bin/activate
   

8. Instal persyaratan untuk loadgen:

   pip3 install -r requirements.txt
   

9. Jalankan loadgen:

   python3 loadgen.py
   

   Saat startup, loadgen akan menampilkan pesan yang mirip dengan berikut ini:

   Starting loadgen: 2019-05-20 10:44:12.448415
   5 request(s) complete to http://localhost:8080
   

   Di jendela terminal lainnya, server menulis pesan ke konsol yang mirip dengan berikut:

   127.0.0.1 - - [21/Jun/2019 14:22:01] "GET / HTTP/1.1" 200 -
   INFO:root:GET request,
   Path: /
   Headers:
   Host: localhost:8080
   User-Agent: python-requests/2.22.0
   Accept-Encoding: gzip, deflate
   Accept: */*
   

   Dari sudut pandang jaringan, seluruh aplikasi kini berjalan di host yang sama. Oleh karena itu, Anda dapat menggunakan localhost untuk mengirim permintaan ke server.

10. Untuk menghentikan loadgen dan server, masukkan Ctrl-c di setiap jendela terminal.

11. Di jendela terminal loadgen, nonaktifkan lingkungan virtual:

    deactivate
    

Mem-build aplikasi dalam container

Untuk menjalankan aplikasi di GKE, Anda harus memaketkan aplikasi contoh—server dan loadgen—ke dalam container. Container adalah cara untuk mengemas aplikasi sehingga terisolasi dari lingkungan yang mendasarinya.

Untuk membuat aplikasi dalam penampung, Anda memerlukan Dockerfile. Dockerfile adalah file teks yang menentukan perintah yang diperlukan untuk menyusun kode sumber aplikasi dan dependensinya menjadi image Docker. Setelah mem-build image, Anda menguploadnya ke registry container, seperti Docker Hub atau Container Registry.

Contoh ini dilengkapi dengan Dockerfile untuk server dan loadgen dengan semua perintah yang diperlukan untuk mem-build image. Berikut adalah Dockerfile untuk server:

FROM python:3.13-slim as base
FROM base as builder
RUN apt-get -qq update \
    && apt-get install -y --no-install-recommends \
        g++ \
    && rm -rf /var/lib/apt/lists/*

# Enable unbuffered logging
FROM base as final
ENV PYTHONUNBUFFERED=1

RUN apt-get -qq update \
    && apt-get install -y --no-install-recommends \
        wget

WORKDIR /helloserver

# Grab packages from builder
COPY --from=builder /usr/local/lib/python3.* /usr/local/lib/

# Add the application
COPY . .

EXPOSE 8080
ENTRYPOINT [ "python", "server.py" ]

• Perintah FROM python:3-slim as base memberi tahu Docker untuk menggunakan image Python 3 terbaru sebagai image dasar.
• Perintah COPY . . menyalin file sumber di direktori kerja saat ini (dalam hal ini, hanya server.py) ke sistem file penampung.
• ENTRYPOINT menentukan perintah yang digunakan untuk menjalankan container. Dalam kasus ini, perintahnya hampir sama dengan yang Anda gunakan untuk menjalankan server.py dari kode sumber.
• Perintah EXPOSE menentukan bahwa server memproses port 8080. Perintah ini tidak mengekspos port apa pun, tetapi berfungsi sebagai dokumentasi bahwa Anda perlu membuka port 8080 saat menjalankan penampung.

Menyiapkan aplikasi untuk dikontainerisasi

1. Tetapkan variabel lingkungan berikut. Ganti PROJECT_ID dengan ID Google Cloud project Anda.

   export PROJECT_ID="PROJECT_ID"

   export GCR_REPO="asm-ready"

   Anda menggunakan nilai PROJECT_ID dan GCR_REPO untuk memberi tag pada image Docker saat Anda membangun lalu mengirimkannya ke Container Registry pribadi.

2. Tetapkan project default untuk Google Cloud CLI. Google Cloud

   gcloud config set project $PROJECT_ID

3. Tetapkan zona default untuk Google Cloud CLI.

   gcloud config set compute/zone us-central1-b
   

4. Pastikan layanan Container Registry diaktifkan di projectGoogle Cloud Anda.

   gcloud services enable containerregistry.googleapis.com
   

Membuat server dalam container

1. Ubah ke direktori tempat server sampel berada:

   cd YOUR_WORKING_DIRECTORY/anthos-service-mesh-samples/docs/helloserver/server/

2. Bangun image menggunakan Dockerfile dan variabel lingkungan yang Anda tentukan sebelumnya:

   docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .
   

   Flag -t mewakili tag Docker. Ini adalah nama image yang Anda gunakan saat men-deploy container.

3. Kirim image ke Container Registry:

   docker push gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1
   

Membuat loadgen dalam container

1. Ubah ke direktori tempat loadgen sampel berada:

   cd ../loadgen
   

2. Buat gambar:

   docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1 .
   

3. Kirim image ke Container Registry:

   docker push gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1
   

Mencantumkan gambar

Dapatkan daftar gambar di repositori untuk mengonfirmasi bahwa gambar telah di-push:

gcloud container images list --repository gcr.io/$PROJECT_ID/asm-ready

Perintah ini akan merespons dengan nama image yang baru saja Anda kirim:

NAME
gcr.io/PROJECT_ID/asm-ready/helloserver
gcr.io/PROJECT_ID/asm-ready/loadgen

Membuat cluster GKE

Anda dapat menjalankan container ini di VM Cloud Shell menggunakan perintah docker run. Namun, dalam produksi, Anda perlu mengatur container dengan cara yang lebih terpadu. Misalnya, Anda memerlukan sistem yang memastikan bahwa penampung selalu berjalan, dan Anda memerlukan cara untuk menskalakan dan memulai instance tambahan penampung untuk menangani peningkatan traffic.

Anda dapat menggunakan GKE untuk menjalankan aplikasi dalam container. GKE adalah platform orkestrasi kontainer yang berfungsi dengan menghubungkan VM ke cluster. Setiap VM disebut sebagai node. Cluster GKE didukung oleh sistem pengelolaan cluster open source Kubernetes. Kubernetes menyediakan mekanisme yang digunakan untuk berinteraksi dengan cluster Anda.

Untuk membuat cluster GKE:

1. Membuat cluster:

   gcloud container clusters create asm-ready \
     --cluster-version latest \
     --machine-type=n1-standard-4 \
     --num-nodes 4
   

   Perintah gcloud akan membuat cluster di project dan zonaGoogle Cloud yang Anda tetapkan sebelumnya. Untuk menjalankan Cloud Service Mesh, sebaiknya gunakan minimal 4 node dan jenis mesin n1-standard-4.

   Perintah untuk membuat cluster memerlukan waktu beberapa menit hingga selesai. Setelah cluster siap, perintah akan menghasilkan output pesan yang mirip dengan berikut ini:

   NAME        LOCATION       MASTER_VERSION  MASTER_IP      MACHINE_TYPE   NODE_VERSION   NUM_NODES  STATUS
   asm-ready  us-central1-b  1.13.5-gke.10   203.0.113.1    n1-standard-2  1.13.5-gke.10  4          RUNNING
   

2. Berikan kredensial ke alat command line kubectl agar Anda dapat menggunakannya untuk mengelola cluster:

   gcloud container clusters get-credentials asm-ready
   

3. Sekarang Anda dapat menggunakan kubectl untuk berkomunikasi dengan Kubernetes. Misalnya, Anda dapat menjalankan perintah berikut untuk mendapatkan status node:

   kubectl get nodes
   

   Perintah ini akan direspons dengan daftar node, yang mirip dengan berikut ini:

   NAME                                       STATUS   ROLES    AGE    VERSION
   gke-asm-ready-default-pool-dbeb23dc-1vg0   Ready    <none>   99s    v1.13.6-gke.13
   gke-asm-ready-default-pool-dbeb23dc-36z5   Ready    <none>   100s   v1.13.6-gke.13
   gke-asm-ready-default-pool-dbeb23dc-fj7s   Ready    <none>   99s    v1.13.6-gke.13
   gke-asm-ready-default-pool-dbeb23dc-wbjw   Ready    <none>   99s    v1.13.6-gke.13
   

Memahami konsep utama Kubernetes

Diagram berikut menggambarkan aplikasi yang berjalan di GKE:

Sebelum men-deploy container ke GKE, sebaiknya tinjau beberapa konsep utama Kubernetes. Di akhir tutorial ini, Anda akan menemukan link agar dapat mempelajari lebih lanjut setiap konsep.

• Node dan cluster: Di GKE, node adalah VM. Di platform Kubernetes lainnya, node dapat berupa mesin fisik atau virtual. Cluster adalah sekumpulan node yang dapat diperlakukan bersama sebagai satu mesin, tempat Anda men-deploy aplikasi dalam container.

• Pod: Di Kubernetes, container berjalan di dalam Pod. Pod adalah unit atomik di Kubernetes. Pod menampung satu atau beberapa container. Anda men-deploy container server dan loadgen masing-masing di Pod-nya sendiri. Saat Pod menjalankan beberapa container (misalnya, server aplikasi dan server proxy), container dikelola sebagai satu entitas dan berbagi resource Pod.

• Deployment: Deployment adalah objek Kubernetes yang merepresentasikan serangkaian Pod yang identik. Deployment menjalankan beberapa replika Pod yang didistribusikan di antara node cluster. Deployment akan otomatis mengganti Pod yang gagal atau tidak merespons.

• Layanan Kubernetes: Menjalankan kode aplikasi di GKE mengubah jaringan antara loadgen dan server. Saat menjalankan layanan di VM Cloud Shell, Anda dapat mengirim permintaan ke server menggunakan alamat localhost:8080. Setelah Anda men-deploy ke GKE, Pod dijadwalkan untuk berjalan di node yang tersedia. Secara default, Anda tidak dapat mengontrol node tempat Pod berjalan, sehingga Pod tidak memiliki alamat IP yang stabil.

  Untuk mendapatkan alamat IP untuk server, Anda harus menentukan abstraksi jaringan di atas Pod yang disebut Service Kubernetes. Service Kubernetes menyediakan endpoint jaringan yang stabil untuk sekumpulan Pod. Ada beberapa jenis Layanan. server menggunakan LoadBalancer, yang mengekspos alamat IP eksternal sehingga Anda dapat menjangkau server dari luar cluster.

  Kubernetes juga memiliki sistem DNS bawaan, yang menetapkan nama DNS (misalnya, helloserver.default.cluster.local) ke Layanan. Hal ini memungkinkan Pod di dalam cluster menjangkau Pod lain di cluster dengan alamat yang stabil. Anda tidak dapat menggunakan nama DNS ini di luar cluster, seperti dari Cloud Shell.

Manifes Kubernetes

Saat menjalankan aplikasi dari kode sumber, Anda menggunakan perintah imperatif: python3 server.py

Imperatif berarti didorong oleh kata kerja: "lakukan ini".

Sebaliknya, Kubernetes beroperasi pada model deklaratif. Artinya, alih-alih memberi tahu Kubernetes secara persis apa yang harus dilakukan, Anda memberi tahu Kubernetes status yang diinginkan. Misalnya, Kubernetes memulai dan menghentikan Pod sesuai kebutuhan sehingga status sistem yang sebenarnya cocok dengan status yang diinginkan.

Anda menentukan status yang diinginkan dalam serangkaian manifes, atau file YAML. File YAML berisi spesifikasi untuk satu atau beberapa objek Kubernetes.

Contoh ini berisi file YAML untuk server dan loadgen. Setiap file YAML menentukan status yang diinginkan untuk objek Deployment dan Service Kubernetes.

Server

apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloserver
spec:
  replicas: 1
  selector:
    matchLabels:
      app: helloserver
  template:
    metadata:
      labels:
        app: helloserver
    spec:
      containers:
      - image: gcr.io/google-samples/istio/helloserver:v0.0.1
        imagePullPolicy: Always
        name: main
      restartPolicy: Always
      terminationGracePeriodSeconds: 5

• kind menunjukkan jenis objek.
• metadata.name menentukan nama Deployment.
• Kolom spec pertama berisi deskripsi status yang diinginkan.
• spec.replicas menentukan jumlah Pod yang diinginkan.
• Bagian spec.template menentukan template Pod. Termasuk dalam spesifikasi untuk Pod adalah kolom image, yang merupakan nama image yang akan ditarik dari Container Registry.

Layanan didefinisikan sebagai berikut:

apiVersion: v1
kind: Service
metadata:
  name: hellosvc
spec:
  ports:
  - name: http
    port: 80
    targetPort: 8080
  selector:
    app: helloserver
  type: LoadBalancer

• LoadBalancer: Klien mengirim permintaan ke alamat IP load balancer jaringan, yang memiliki alamat IP stabil dan dapat dijangkau di luar cluster.
• targetPort: Ingatlah bahwa perintah EXPOSE 8080 di Dockerfile sebenarnya tidak mengekspos port apa pun. Anda mengekspos port 8080 sehingga Anda dapat menjangkau container server di luar cluster. Dalam hal ini, hellosvc.default.cluster.local:80 (nama pendek: hellosvc) dipetakan ke port 8080 IP Pod helloserver.
• port: Ini adalah nomor port yang digunakan layanan lain di cluster saat mengirim permintaan.

Generator Beban

Objek Deployment di loadgen.yaml mirip dengan server.yaml. Salah satu perbedaan yang mencolok adalah objek Deployment berisi bagian yang disebut env. Bagian ini menentukan variabel lingkungan yang diperlukan oleh loadgen, yang Anda tetapkan sebelumnya saat menjalankan aplikasi dari sumber.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: loadgenerator
spec:
  replicas: 1
  selector:
    matchLabels:
      app: loadgenerator
  template:
    metadata:
      labels:
        app: loadgenerator
    spec:
      containers:
      - env:
        - name: SERVER_ADDR
          value: http://hellosvc:80/
        - name: REQUESTS_PER_SECOND
          value: '10'
        image: gcr.io/google-samples/istio/loadgen:v0.0.1
        imagePullPolicy: Always
        name: main
        resources:
          limits:
            cpu: 500m
            memory: 512Mi
          requests:
            cpu: 300m
            memory: 256Mi
      restartPolicy: Always
      terminationGracePeriodSeconds: 5

Karena loadgen tidak menerima permintaan masuk, kolom type ditetapkan ke ClusterIP. Jenis ini menyediakan alamat IP stabil yang dapat digunakan oleh layanan di cluster, tetapi alamat IP tidak diekspos ke klien eksternal.

apiVersion: v1
kind: Service
metadata:
  name: loadgensvc
spec:
  ports:
  - name: http
    port: 80
    targetPort: 8080
  selector:
    app: loadgenerator
  type: ClusterIP

Men-deploy container ke GKE

1. Ubah ke direktori tempat server sampel berada:

   cd YOUR_WORKING_DIRECTORY/anthos-service-mesh-samples/docs/helloserver/server/

2. Buka server.yaml di editor teks.

3. Ganti nama di kolom image dengan nama image Docker Anda.

   image: gcr.io/PROJECT_ID/asm-ready/helloserver:v0.0.1
   

   Ganti PROJECT_ID dengan Google Cloud project ID Anda.

4. Simpan dan tutup server.yaml.

5. Deploy file YAML ke Kubernetes:

   kubectl apply -f server.yaml
   

   Jika berhasil, perintah akan merespons dengan:

   deployment.apps/helloserver created
   service/hellosvc created
   

6. Ubah ke direktori tempat loadgen berada.

   cd ../loadgen
   

7. Buka loadgen.yaml di editor teks.

8. Ganti nama di kolom image dengan nama image Docker Anda.

   image: gcr.io/PROJECT_ID/asm-ready/loadgen:v0.0.1
   

   Ganti PROJECT_ID dengan Google Cloud project ID Anda.

9. Simpan dan tutup loadgen.yaml, lalu tutup editor teks.

10. Deploy file YAML ke Kubernetes:

    kubectl apply -f loadgen.yaml
    

    Jika berhasil, perintah akan merespons dengan:

    deployment.apps/loadgenerator created
    service/loadgensvc created
    

11. Periksa status Pod:

    kubectl get pods
    

    Perintah ini akan direspons dengan status yang mirip dengan berikut ini:

    NAME                             READY   STATUS    RESTARTS   AGE
    helloserver-69b9576d96-mwtcj     1/1     Running   0          58s
    loadgenerator-774dbc46fb-gpbrz   1/1     Running   0          57s
    

12. Dapatkan log aplikasi dari Pod loadgen. Ganti POD_ID dengan ID dari output sebelumnya.

    kubectl logs loadgenerator-POD_ID
    

13. Dapatkan alamat IP eksternal hellosvc:

    kubectl get service
    

    Respons perintahnya mirip dengan berikut ini:

    NAME         TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
    hellosvc     LoadBalancer   10.81.15.158   192.0.2.1       80:31127/TCP   33m
    kubernetes   ClusterIP      10.81.0.1      <none>          443/TCP        93m
    loadgensvc   ClusterIP      10.81.15.155   <none>          80/TCP         4m52s
    

14. Kirim permintaan ke hellosvc. Ganti EXTERNAL_IP dengan alamat IP eksternal hellosvc Anda.

    curl http://EXTERNAL_IP
    

Siap untuk Cloud Service Mesh

Sekarang Anda telah men-deploy aplikasi ke GKE. loadgen dapat menggunakan DNS Kubernetes (hellosvc:80) untuk mengirim permintaan keserver, dan Anda dapat mengirim permintaan ke server dengan alamat IP eksternal. Meskipun Kubernetes memberi Anda banyak fitur, beberapa informasi tentang layanan tidak ada:

• Bagaimana layanan berinteraksi? Apa hubungan antara layanan tersebut? Bagaimana alur traffic di antara layanan? Anda tahu bahwa loadgen mengirim permintaan ke server, tetapi bayangkan Anda tidak terbiasa dengan aplikasi tersebut. Anda tidak dapat menjawab pertanyaan ini dengan melihat daftar Pod yang berjalan di GKE.
• Metrik: Berapa lama waktu yang dibutuhkan server untuk merespons permintaan masuk? Berapa banyak permintaan per detik (RPS) yang masuk ke server? Apakah ada respons error?
• Informasi keamanan: Apakah traffic antara loadgen dan server menggunakan mTLS atau tidak dienkripsi (plain)?HTTP

Cloud Service Mesh dapat memberikan jawaban atas pertanyaan-pertanyaan ini. Cloud Service Mesh adalah versi terkelola Google Clouddari project Istio open source. Cloud Service Mesh berfungsi dengan menempatkan proxy file bantuan Envoy di setiap Pod. Proxy Envoy mencegat semua traffic masuk dan keluar ke container aplikasi. Artinya, server dan loadgen masing-masing mendapatkan proxy file bantuan Envoy, dan semua traffic dari loadgen ke server dimediasi oleh proxy Envoy. Koneksi antara proxy Envoy ini membentuk mesh layanan. Arsitektur mesh layanan ini menyediakan lapisan kontrol di atas Kubernetes.

Karena proxy Envoy berjalan di container-nya sendiri, Anda dapat menginstal Cloud Service Mesh di atas cluster GKE tanpa perubahan substansial pada kode aplikasi Anda. Namun, ada beberapa cara utama yang Anda lakukan untuk menyiapkan aplikasi agar diinstrumentasikan dengan Cloud Service Mesh:

• Layanan untuk semua container: Deployment server dan loadgen memiliki layanan Kubernetes yang terlampir. Bahkan loadgen, yang tidak menerima permintaan masuk, memiliki layanan.
• Port dalam layanan harus diberi nama: Meskipun GKE memungkinkan Anda menentukan port layanan yang tidak diberi nama, Cloud Service Mesh mengharuskan Anda memberikan nama untuk port yang cocok dengan protokol port. Dalam file YAML, port untuk server diberi nama http karena server menggunakan protokol komunikasi HTTP. Jika service menggunakan gRPC, Anda akan memberi nama port grpc.
• Deployment diberi label: Hal ini memungkinkan Anda menggunakan fitur pengelolaan traffic Cloud Service Mesh seperti memisahkan traffic antar-versi layanan yang sama.

Menginstal Cloud Service Mesh

Buka panduan penginstalan Cloud Service Mesh dan ikuti petunjuk untuk menginstal Cloud Service Mesh di cluster Anda.