Halaman ini diterjemahkan oleh Cloud Translation API.

Memperkenalkan penampung

Jika Anda sama sekali tidak memahami beban kerja dalam container, tutorial ini cocok untuk Anda. Tutorial ini memperkenalkan container dan orkestrasi container dengan memandu Anda menyiapkan aplikasi sederhana dari kode sumber ke container yang berjalan di GKE.

Tutorial ini tidak memerlukan pengalaman sebelumnya dengan penampung atau Kubernetes. Namun, jika Anda ingin membaca ringkasan terminologi Kubernetes inti sebelum memulai tutorial ini, lihat Mulai mempelajari Kubernetes (atau jika Anda lebih suka mempelajari Kubernetes dalam bentuk komik, lihat komik Kubernetes kami). Anda akan menemukan resource yang lebih mendetail di bagian Langkah berikutnya di akhir tutorial.

Jika sudah memahami container dan Kubernetes, Anda dapat melewati tutorial ini dan mulai mempelajari GKE itu sendiri.

Tujuan

Jelajahi aplikasi "hello world" multi-layanan sederhana.
Jalankan aplikasi dari sumber.
Memasukkan aplikasi ke dalam container.
Membuat cluster Kubernetes.
Deploy container ke cluster.

Sebelum memulai

Lakukan langkah-langkah berikut untuk mengaktifkan Kubernetes Engine API:

Buka halaman Kubernetes Engine di Konsol Google Cloud.
Buat atau pilih project.
Tunggu hingga API dan layanan terkait diaktifkan. Proses ini dapat memerlukan waktu beberapa menit.
Make sure that billing is enabled for your Google Cloud project.

Menyiapkan Cloud Shell

Tutorial ini menggunakan Cloud Shell, yang menyediakan virtual machine (VM) Compute Engine g1-small yang menjalankan sistem operasi Linux berbasis Debian.

Menggunakan Cloud Shell memiliki keunggulan berikut:

Lingkungan pengembangan Python 3 (termasuk virtualenv) telah disiapkan sepenuhnya.
Alat command line gcloud, docker, git, dan kubectl yang digunakan dalam tutorial ini sudah diinstal.
Anda dapat memilih editor teks bawaan:
- Cloud Shell Editor, yang dapat Anda akses dengan mengklik Open Editor di bagian atas jendela Cloud Shell.
- Emacs, Vim, atau Nano, yang Anda akses dari command line di Cloud Shell.

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

Mendownload kode contoh

Download kode sumber helloserver:

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

Ubah ke direktori kode contoh:

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

Menjelajahi aplikasi multi-layanan

Aplikasi contoh ditulis dalam Python. Model 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.

Contoh aplikasi

Menjalankan aplikasi dari sumber

Untuk memahami aplikasi contoh, jalankan di Cloud Shell:

Dari direktori sample-apps/helloserver, jalankan server:
```
python3 server/server.py
```
Saat memulai, server akan menampilkan hal berikut:
```
INFO:root:Starting server...
```
Buka jendela terminal lain agar Anda dapat mengirim permintaan ke server. Untuk melakukannya di Cloud Shell, klik Open a new tab untuk membuka sesi lain.
Di jendela terminal baru, kirim permintaan ke server:
```
curl http://localhost:8080
```
Output dari server adalah sebagai berikut:
```
Hello World!
```
Di tab yang sama, ubah ke direktori yang berisi skrip loadgen:
```
cd anthos-service-mesh-samples/docs/helloserver/loadgen
```

Buat variabel lingkungan berikut:

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

Mulai virtualenv:
```
virtualenv --python python3 env
```
Aktifkan lingkungan virtual:
```
source env/bin/activate
```
Instal persyaratan untuk loadgen:
```
pip3 install -r requirements.txt
```
Jalankan aplikasi loadgen untuk menghasilkan traffic bagi server:
```
python3 loadgen.py
```
Saat memulai, output dari loadgen mirip dengan berikut ini:
```
Starting loadgen: 2024-10-11 09:49:51.798028
5 request(s) complete to http://localhost:8080
```
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.
Untuk menghentikan loadgen dan server, tekan Ctrl-c di setiap jendela terminal.
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 penampung. Penampung adalah paket yang berisi semua elemen yang diperlukan agar aplikasi Anda dapat berjalan di lingkungan apa pun. Tutorial ini menggunakan Docker untuk mengemas aplikasi dalam penampung.

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

Kode sumber untuk tutorial ini menyertakan Dockerfile untuk server dan loadgen dengan semua perintah yang diperlukan untuk mem-build image. Berikut 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:

Petunjuk FROM python:3-slim as base memberi tahu Docker untuk menggunakan image Python 3 terbaru sebagai image dasar.
Petunjuk COPY . . menyalin file sumber dari direktori kerja saat ini (dalam hal ini, server.py) ke sistem file penampung.
ENTRYPOINT menentukan petunjuk yang digunakan untuk menjalankan penampung. Dalam contoh ini, instruksinya 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 Anda perlukan untuk membuka port 8080 saat menjalankan container.

Bersiap untuk membuat container aplikasi

Sebelum melakukan containerisasi aplikasi, Anda perlu melakukan beberapa penyiapan untuk alat dan layanan yang akan digunakan:

Tetapkan project Google Cloud default untuk Google Cloud CLI.
```
gcloud config set project PROJECT_ID
```

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 berikut:

Pastikan layanan Artifact Registry diaktifkan di project Google Cloud Anda.
```
gcloud services enable artifactregistry.googleapis.com
```

Buat repositori Artifact Registry:

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

Siapkan autentikasi dari Docker ke Artifact Registry menggunakan Google Cloud CLI:
```
gcloud auth configure-docker us-central1-docker.pkg.dev
```

Membuat container `server`

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

Ubah ke direktori tempat server contoh berada:

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

Build image menggunakan Dockerfile:
```
docker build -t us-central1-docker.pkg.dev/PROJECT_ID/container-intro/helloserver:v0.0.1 .
```
- Ganti PROJECT_ID dengan ID project Google Cloud Anda.
Flag -t mewakili tag Docker. Ini adalah nama image yang Anda gunakan saat men-deploy container.

Mengirim image ke Artifact Registry:

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

Membuat container `loadgen`

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

Ubah ke direktori tempat loadgen contoh berada:
```
cd ../loadgen
```

Buat gambar:

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

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 image yang Anda kirim, mirip dengan berikut:

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 cukup menjalankan penampung di VM Cloud Shell menggunakan perintah docker run. Namun, untuk menjalankan workload produksi yang andal, Anda perlu mengelola penampung dengan cara yang lebih terpadu. Misalnya, Anda perlu memastikan bahwa penampung dimulai ulang jika gagal, dan Anda memerlukan cara untuk menskalakan ke atas dan memulai instance penampung tambahan untuk menangani peningkatan traffic.

GKE dapat membantu Anda memenuhi kebutuhan ini. GKE adalah platform orkestrasi container yang berfungsi dengan menghubungkan VM ke dalam 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 menjalankan penampung di GKE, Anda harus membuat, lalu menghubungkan ke cluster terlebih dahulu:

Membuat cluster:
```
gcloud container clusters create-auto container-intro
```
Perintah gcloud membuat cluster di project dan region Google Cloud 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
```
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 berdasarkan model deklaratif. Artinya, Anda memberikan status yang diinginkan kepada Kubernetes, bukan memberi tahu Kubernetes secara persis apa yang harus dilakukan. 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 container yang berjalan, dikemas untuk pengelolaan sebagai Pod Kubernetes) dan Layanan (yang menyediakan alamat IP untuk Pod). Pod adalah unit komputasi terkecil yang dapat di-deploy yang dapat Anda buat dan kelola di Kubernetes, dan menyimpan satu atau beberapa penampung.

Diagram berikut menggambarkan aplikasi yang berjalan di GKE:

Aplikasi dalam container 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. Yang disertakan dalam spesifikasi untuk Pod adalah kolom image, yang merupakan nama image yang akan diambil dari Artifact Registry. Pada langkah berikutnya, Anda akan memperbarui ini ke image baru yang baru saja Anda buat.

Layanan hellosvc ditentukan 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 balancing jaringan, yang memiliki alamat IP stabil dan dapat dijangkau di luar cluster.
targetPort: Ingat bahwa perintah EXPOSE 8080 di Dockerfile tidak benar-benar mengekspos port apa pun. Anda mengekspos port 8080 agar dapat menjangkau penampung server di luar cluster. Dalam hal ini, hellosvc.default.cluster.local:80 (nama singkat: hellosvc) dipetakan ke 8080 port IP Pod helloserver.
port: Ini adalah nomor port yang digunakan layanan lain dalam cluster saat mengirim permintaan.

Generator beban

Objek Deployment di loadgen.yaml mirip dengan server.yaml. Salah satu perbedaan yang signifikan adalah spesifikasi Pod untuk Deployment loadgen memiliki kolom 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 Service ini menyediakan alamat IP stabil yang dapat digunakan entity 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 penampung, Anda menerapkan manifes yang menentukan status yang diinginkan menggunakan kubectl.

Men-deploy `server`

Ubah ke direktori tempat server contoh berada:

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

Buka server.yaml di Cloud Shell Editor (atau editor teks pilihan Anda).
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 ID project Google Cloud Anda.
- Jika Anda menggunakan Editor Cloud Shell, file akan otomatis disimpan. Kembali ke jendela terminal dengan mengklik Open terminal.
- Jika Anda menggunakan editor teks di Cloud Shell, simpan dan tutup server.yaml.

Deploy manifes ke Kubernetes:

kubectl apply -f server.yaml

Outputnya mirip dengan hal berikut ini:

deployment.apps/helloserver created
service/hellosvc created

Men-deploy `loadgen`

Ubah ke direktori tempat loadgen berada.
```
cd ../loadgen
```
Buka loadgen.yaml di editor teks, seperti sebelumnya.
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 ID project Google Cloud Anda.
- Jika Anda menggunakan Editor Cloud Shell, file akan otomatis disimpan. Kembali ke jendela terminal dengan mengklik Open terminal.
- Jika Anda menggunakan editor teks di Cloud Shell, simpan dan tutup loadgen.yaml.

Deploy manifes ke cluster Anda:

kubectl apply -f loadgen.yaml

Jika berhasil, perintah akan merespons dengan hal berikut:

deployment.apps/loadgenerator created
service/loadgensvc created

Memverifikasi deployment Anda

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

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

Dapatkan log aplikasi dari Pod loadgen. Ganti POD_ID dengan ID Pod generator beban dari output sebelumnya.
```
kubectl logs POD_ID
```

Dapatkan alamat IP eksternal hellosvc:

kubectl get service hellosvc