Memperkenalkan penampung

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 di Python. Aplikasi ini memiliki komponen berikut yang berkomunikasi menggunakan REST:

• server: Server dasar dengan satu endpoint GET, / , yang mencetak "hello world" ke jendela terminal.
• 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. Untuk melakukannya di Cloud Shell, klik add Open a new tab untuk membuka sesi lain.

3. Di jendela terminal baru, kirim permintaan ke server:

   curl http://localhost:8080
   

   Output dari server adalah sebagai berikut:

   Hello World!
   

4. Di tab yang sama, ubah ke direktori yang berisi skrip loadgen:

   cd 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 aplikasi loadgen untuk menghasilkan traffic untuk server:

   python3 loadgen.py
   

   Saat startup, output dari loadgen mirip dengan berikut ini:

   Starting loadgen: 2024-10-11 09:49:51.798028
   5 request(s) complete to http://localhost:8080
   

10. Sekarang buka jendela terminal yang menjalankan server. Anda akan melihat pesan yang mirip dengan berikut ini:

    127.0.0.1 - - [11/Oct/2024 09:51:28] "GET / HTTP/1.1" 200 -
    INFO:root:GET request,
    Path: /
    Headers:
    Host: localhost:8080
    User-Agent: python-requests/2.32.3
    Accept-Encoding: gzip, deflate
    Accept: */*
    Connection: keep-alive
    

    Dari perspektif jaringan, seluruh aplikasi kini berjalan di host yang sama, yang memungkinkan Anda menggunakan localhost untuk mengirim permintaan ke server.

11. Untuk menghentikan loadgen dan server, tekan Ctrl-c di setiap jendela terminal.

12. Di jendela terminal loadgen, nonaktifkan lingkungan virtual:

    deactivate
    

Mem-build aplikasi dalam container

Untuk menjalankan aplikasi di GKE, Anda perlu mengemas kedua komponen aplikasi contoh ke dalam container. Container adalah paket yang berisi semua elemen yang diperlukan agar aplikasi Anda dapat berjalan di lingkungan apa pun. Tutorial ini menggunakan Docker untuk membuat container aplikasi.

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

Kode sumber untuk tutorial ini mencakup 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" ]

Dalam file ini, Anda dapat melihat hal berikut:

• Instruksi FROM python:3-slim as base memberi tahu Docker untuk menggunakan image Python 3 terbaru sebagai image dasar.
• Instruksi COPY . . menyalin file sumber dari direktori kerja saat ini (dalam hal ini, server.py) ke sistem file container.
• ENTRYPOINT menentukan petunjuk yang digunakan untuk menjalankan container. Dalam contoh ini, petunjuknya mirip dengan yang Anda gunakan untuk menjalankan server.py dari kode sumber.
• Instruksi EXPOSE menentukan bahwa server memproses port 8080. Petunjuk ini tidak mengekspos port apa pun, tetapi berfungsi sebagai dokumentasi yang mengharuskan Anda membuka port 8080 saat menjalankan container.

Menyiapkan aplikasi untuk dikontainerisasi

Sebelum membuat penampung aplikasi, Anda perlu melakukan beberapa penyiapan untuk alat dan layanan yang akan Anda gunakan:

1. Tetapkan project default untuk Google Cloud CLI. Trusted Cloud

   gcloud config set project PROJECT_ID

2. Tetapkan region default untuk Google Cloud CLI.

   gcloud config set compute/region us-central1
   

Membuat repositori

Untuk membuat repositori baru bagi image container Docker di Artifact Registry, lakukan langkah-langkah berikut:

1. Pastikan layanan Artifact Registry diaktifkan di projectTrusted Cloud Anda.

   gcloud services enable artifactregistry.googleapis.com
   
   

2. Buat repositori Artifact Registry:

   gcloud artifacts repositories create container-intro --repository-format=docker \
       --location=us-central1 \
       --description="My new Docker repository"
   

3. Siapkan autentikasi dari Docker ke Artifact Registry menggunakan Google Cloud CLI:

   gcloud auth configure-docker us-central1-docker.pkg.dev
   

Membuat server dalam container

Sekarang saatnya membuat container aplikasi Anda. Pertama, buat container "hello world" server dan kirim image ke Artifact Registry:

1. Ubah ke direktori tempat server sampel berada:

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

2. Bangun image menggunakan Dockerfile:

   docker build -t us-central1-docker.pkg.dev/PROJECT_ID/container-intro/helloserver:v0.0.1 .
   

   • Ganti PROJECT_ID dengan ID Trusted Cloud by S3NS project Anda.

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

3. Mengirim image ke Artifact Registry:

   docker push us-central1-docker.pkg.dev/PROJECT_ID/container-intro/helloserver:v0.0.1
   

Membuat loadgen dalam container

Selanjutnya, buat layanan generator beban dalam penampung dengan cara yang sama:

1. Ubah ke direktori tempat loadgen sampel berada:

   cd ../loadgen
   

2. Buat gambar:

   docker build -t us-central1-docker.pkg.dev/PROJECT_ID/container-intro/loadgen:v0.0.1 .
   

3. Mengirim image ke Artifact Registry:

   docker push us-central1-docker.pkg.dev/PROJECT_ID/container-intro/loadgen:v0.0.1
   

Mencantumkan gambar

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

gcloud container images list --repository us-central1-docker.pkg.dev/PROJECT_ID/container-intro

Output akan mencantumkan nama gambar yang Anda kirim, mirip dengan berikut ini:

NAME
us-central1-docker.pkg.dev/PROJECT_ID/container-intro/helloserver
us-central1-docker.pkg.dev/PROJECT_ID/container-intro/loadgen

Membuat cluster GKE

Pada tahap ini, Anda dapat menjalankan container di VM Cloud Shell dengan menggunakan perintah docker run. Namun, untuk menjalankan workload produksi yang andal, Anda perlu mengelola container dengan cara yang lebih terpadu. Misalnya, Anda perlu memastikan bahwa container dimulai ulang jika gagal, dan Anda memerlukan cara untuk menskalakan dan memulai instance tambahan container untuk menangani peningkatan traffic.

GKE dapat membantu Anda memenuhi kebutuhan ini. GKE adalah platform orkestrasi container 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.

Untuk menjalankan container di GKE, Anda harus membuat lalu terhubung ke cluster terlebih dahulu:

1. Membuat cluster:

   gcloud container clusters create-auto container-intro
   

   Perintah gcloud akan membuat cluster di project Trusted Cloud dan region default yang Anda tetapkan sebelumnya.

   Perintah untuk membuat cluster memerlukan waktu beberapa menit hingga selesai. Jika cluster sudah siap, output-nya akan mirip dengan berikut ini:

    NAME: container-intro
    LOCATION: us-central1
    MASTER_VERSION: 1.30.4-gke.1348000
    MASTER_IP: 34.44.14.166
    MACHINE_TYPE: e2-small
    NODE_VERSION: 1.30.4-gke.1348000
    NUM_NODES: 3
    STATUS: RUNNING
   

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

   gcloud container clusters get-credentials container-intro
   

Memeriksa 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 file yang disebut manifes. Manifes ditulis dalam bahasa seperti YAML atau JSON dan berisi spesifikasi untuk satu atau beberapa objek Kubernetes.

Contoh ini berisi manifes untuk server dan loadgen. Setiap manifes menentukan status yang diinginkan untuk objek Deployment Kubernetes (yang mengelola jalannya penampung Anda, yang dipaketkan untuk pengelolaan sebagai Pod Kubernetes) dan Service (yang menyediakan alamat IP untuk Pod). Pod adalah unit komputasi terapan terkecil yang dapat Anda buat dan kelola di Kubernetes, dan menampung satu atau beberapa container.

Diagram berikut menggambarkan aplikasi yang berjalan di GKE:

Anda dapat mempelajari Pod, Deployment, dan Layanan lebih lanjut di Mulai mempelajari Kubernetes, atau di referensi di akhir halaman ini.

Server

Pertama, lihat manifes untuk server "hello world":

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

Manifes ini berisi kolom berikut:

• 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. Kolom image disertakan dalam spesifikasi untuk Pod, yang merupakan nama image yang akan ditarik dari Artifact Registry. Pada langkah berikutnya, Anda akan memperbarui ini ke gambar baru yang baru saja Anda buat.

Layanan hellosvc 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 penting adalah spesifikasi Pod untuk Deployment loadgen memiliki kolom bernama env. Bagian ini menentukan variabel lingkungan yang diperlukan oleh loadgen, yang sebelumnya Anda tetapkan 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 Service ini menyediakan alamat IP stabil yang dapat digunakan oleh entitas 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

Untuk men-deploy container, Anda menerapkan manifes yang menentukan status yang diinginkan dengan menggunakan kubectl.

Deploy server

1. Ubah ke direktori tempat server sampel berada:

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

2. Buka server.yaml di Cloud Shell Editor (atau editor teks pilihan Anda).

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

   image: us-central1-docker.pkg.dev/PROJECT_ID/container-intro/helloserver:v0.0.1
   

   Ganti PROJECT_ID dengan Trusted Cloud project ID Anda.

   • Jika Anda menggunakan Cloud Shell Editor, file akan disimpan secara otomatis. Kembali ke jendela terminal dengan mengklik Open terminal.
   • Jika Anda menggunakan editor teks di Cloud Shell, simpan dan tutup server.yaml.

4. Deploy manifes ke Kubernetes:

   kubectl apply -f server.yaml
   

   Outputnya mirip dengan hal berikut ini:

   deployment.apps/helloserver created
   service/hellosvc created
   

Deploy loadgen

1. Ubah ke direktori tempat loadgen berada.

   cd ../loadgen
   

2. Buka loadgen.yaml di editor teks, seperti sebelumnya.

3. Sekali lagi, ganti nama di kolom image dengan nama image Docker Anda.

   image: us-central1-docker.pkg.dev/PROJECT_ID/container-intro/loadgen:v0.0.1
   

   Ganti PROJECT_ID dengan Trusted Cloud project ID Anda.

   • Jika Anda menggunakan Cloud Shell Editor, file akan disimpan secara otomatis. Kembali ke jendela terminal dengan mengklik Open terminal.
   • Jika Anda menggunakan editor teks di Cloud Shell, simpan dan tutup loadgen.yaml.

4. Deploy manifes ke cluster Anda:

   kubectl apply -f loadgen.yaml
   

   Jika berhasil, perintah akan merespons dengan:

   deployment.apps/loadgenerator created
   service/loadgensvc created
   

Memverifikasi deployment Anda

Setelah men-deploy manifes ke cluster, verifikasi bahwa penampung Anda telah berhasil di-deploy:

1. Periksa status Pod di cluster Anda:

   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
   

2. Dapatkan log aplikasi dari Pod loadgen. Ganti POD_ID dengan ID Pod generator beban dari output sebelumnya.

   kubectl logs POD_ID
   

3. Dapatkan alamat IP eksternal hellosvc:

   kubectl get service hellosvc
   

   Outputnya mirip dengan hal 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
   

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

   curl http://EXTERNAL_IP
   

   Anda akan melihat pesan "Hello World!" dari server.