Cluster Anthos on bare metal kini menjadi Google Distributed Cloud (khusus software) untuk bare metal. Untuk mengetahui informasi selengkapnya, lihat ringkasan produk.

Halaman ini diterjemahkan oleh Cloud Translation API.

Men-deploy aplikasi

Dokumen ini menjelaskan cara men-deploy aplikasi di Google Distributed Cloud.

Sebelum memulai

Untuk men-deploy workload, Anda harus memiliki cluster pengguna, campuran, atau mandiri yang dapat menjalankan workload.

Membuat Deployment

Langkah-langkah berikut akan membuat Deployment di cluster Anda:

Salin manifes berikut ke file bernama my-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
spec:
  selector:
    matchLabels:
      app: metrics
      department: sales
  replicas: 3
  template:
    metadata:
      labels:
        app: metrics
        department: sales
    spec:
      containers:
      - name: hello
        image: "us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0"

Gunakan kubectl apply untuk membuat Deployment:
```
kubectl apply -f my-deployment.yaml --kubeconfig CLUSTER_KUBECONFIG
```
Ganti CLUSTER_KUBECONFIG dengan jalur file kubeconfig untuk cluster Anda.

Dapatkan informasi dasar tentang Deployment Anda untuk mengonfirmasi bahwa deployment berhasil dibuat:

kubectl get deployment my-deployment --kubeconfig CLUSTER_KUBECONFIG

Output menunjukkan bahwa Deployment memiliki tiga Pod yang semuanya tersedia:

NAME            READY   UP-TO-DATE   AVAILABLE   AGE
my-deployment   3/3     3            3           27s

Cantumkan Pod di Deployment Anda:

kubectl get pods --kubeconfig CLUSTER_KUBECONFIG

Output menunjukkan bahwa Deployment Anda memiliki tiga Pod yang sedang berjalan:

NAME                             READY   STATUS    RESTARTS   AGE
my-deployment-869f65669b-5259x   1/1     Running   0          34s
my-deployment-869f65669b-9xfrs   1/1     Running   0          34s
my-deployment-869f65669b-wn4ft   1/1     Running   0          34s

Dapatkan informasi mendetail tentang Deployment Anda:

kubectl get deployment my-deployment --output yaml --kubeconfig CLUSTER_KUBECONFIG

Output menampilkan detail tentang spesifikasi dan status Deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  ...
  generation: 1
  name: my-deployment
  namespace: default
  ...
spec:
  ...
  replicas: 3
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: metrics
      department: sales
  ...
    spec:
      containers:
      - image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0
        imagePullPolicy: IfNotPresent
        name: hello
        resources: {}
        terminationMessagePath: /dev/termination-log
        terminationMessagePolicy: File
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      terminationGracePeriodSeconds: 30
status:
  availableReplicas: 3
  conditions:
  - lastTransitionTime: "2023-06-29T16:17:17Z"
    lastUpdateTime: "2023-06-29T16:17:17Z"
    message: Deployment has minimum availability.
    reason: MinimumReplicasAvailable
    status: "True"
    type: Available
  - lastTransitionTime: "2023-06-29T16:17:12Z"
    lastUpdateTime: "2023-06-29T16:17:17Z"
    message: ReplicaSet "my-deployment-869f65669b" has successfully progressed.
    reason: NewReplicaSetAvailable
    status: "True"
    type: Progressing
  observedGeneration: 1
  readyReplicas: 3
  replicas: 3
  updatedReplicas: 3

Jelaskan Deployment Anda:

kubectl describe deployment my-deployment --kubeconfig CLUSTER_KUBECONFIG

Output akan menampilkan detail Deployment yang diformat dengan baik, termasuk ReplicaSet terkait:

Name:                   my-deployment
Namespace:              default
CreationTimestamp:      Thu, 29 Jun 2023 16:17:12 +0000
Labels:                 <none>
Annotations:            deployment.kubernetes.io/revision: 1
Selector:               app=metrics,department=sales
Replicas:               3 desired | 3 updated | 3 total | 3 available | 0 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge
Pod Template:
  Labels:  app=metrics
          department=sales
  Containers:
  hello:
    Image:        us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0
    Port:         <none>
    Host Port:    <none>
    Environment:  <none>
    Mounts:       <none>
  Volumes:        <none>
Conditions:
  Type           Status  Reason
  ----           ------  ------
  Available      True    MinimumReplicasAvailable
  Progressing    True    NewReplicaSetAvailable
OldReplicaSets:  <none>
NewReplicaSet:   my-deployment-869f65669b (3/3 replicas created)
Events:
  Type    Reason             Age    From                   Message
  ----    ------             ----   ----                   -------
  Normal  ScalingReplicaSet  6m50s  deployment-controller  Scaled up replica set my-deployment-869f65669b to 3

Membuat Service jenis `LoadBalancer`

Salah satu cara untuk mengekspos Deployment ke klien di luar cluster adalah dengan membuat Layanan Kubernetes jenis LoadBalancer.

Untuk membuat Service jenis LoadBalancer:

Salin manifes berikut ke file bernama my-service.yaml:
```
apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: metrics
    department: sales
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8080
```
Berikut adalah hal-hal penting yang perlu dipahami tentang Layanan dalam latihan ini:
- Setiap Pod yang memiliki label app: metrics dan label department: sales adalah anggota Layanan. Pod di my-deployment memiliki label ini.
- Saat klien mengirim permintaan ke Layanan di port TCP80, permintaan tersebut akan diteruskan ke Pod anggota di port TCP 8080.
- Setiap Pod anggota harus memiliki container yang memproses port TCP 8080.
Secara default, penampung hello-app memproses port TCP 8080. Anda dapat melihat setelan port ini dengan melihat Dockerfile dan kode sumber untuk aplikasi.
Gunakan kubectl apply untuk membuat Layanan di cluster Anda:
```
kubectl apply -f my-service.yaml --kubeconfig CLUSTER_KUBECONFIG
```
Ganti CLUSTER_KUBECONFIG dengan jalur file kubeconfig untuk cluster Anda.
Lihat Layanan Anda:
```
kubectl get service my-service --output yaml --kubeconfig CLUSTER_KUBECONFIG
```
Outputnya mirip dengan hal berikut ini:
```
apiVersion: v1
kind: Service
metadata:
  ...
  name: my-service
  namespace: default
  ...
spec:
  allocateLoadBalancerNodePorts: true
  clusterIP: 10.96.2.165
  clusterIPs:
  - 10.96.2.165
  externalTrafficPolicy: Cluster
  internalTrafficPolicy: Cluster
  ipFamilies:
  - IPv4
  ipFamilyPolicy: SingleStack
  ports:
  - nodePort: 31565
    port: 80
    protocol: TCP
    targetPort: 8080
  selector:
    app: metrics
    department: sales
  sessionAffinity: None
  type: LoadBalancer
status:
  loadBalancer:
    ingress:
    - ip: 192.168.1.13
```
Pada output sebelumnya, Anda dapat melihat bahwa Layanan Anda memiliki clusterIP, dan alamat IP eksternal. Class ini juga memiliki nodePort, port, dan targetPort.

clusterIP tidak relevan dengan latihan ini. Alamat IP eksternal (status.loadBalancer.ingress.ip) berasal dari rentang alamat yang Anda tentukan saat menentukan kumpulan alamat load balancer (spec.loadBalancer.addressPools) dalam file konfigurasi cluster.

Sebagai contoh, ambil nilai yang ditampilkan dalam output sebelumnya untuk Layanan Anda:
- Alamat IP eksternal: 192.168.1.13
- port: 80
- nodePort: 31565
- targetPort: 8080
Klien mengirimkan permintaan ke 192.168.1.13 pada port TCP 80. Permintaan tersebut diarahkan ke load balancer Anda, dan dari sana diteruskan ke Pod anggota di port TCP 8080.
Panggil Layanan Anda:
```
curl INGRESS_IP_ADDRESS
```
Ganti INGRESS_IP_ADDRESS dengan alamat IP masuk di bagian status Layanan yang Anda ambil di langkah sebelumnya (status.loadBalancer.ingress).

Output menampilkan pesan Hello, world!:
```
Hello, world!
Version: 2.0.0
Hostname: my-deployment-869f65669b-wn4ft
```

Batas port LoadBalancer

Jenis LoadBalancer adalah ekstensi dari jenis NodePort. Jadi, Service jenis LoadBalancer memiliki alamat IP cluster dan satu atau beberapa nilai nodePort. Secara default, Kubernetes mengalokasikan port node ke Service jenis LoadBalancer. Alokasi ini dapat dengan cepat menghabiskan port node yang tersedia dari 2.768 yang dialokasikan ke cluster Anda. Untuk menyimpan port node, nonaktifkan alokasi port node load balancer dengan menetapkan kolom allocateLoadBalancerNodePorts ke false dalam spesifikasi Layanan LoadBalancer. Setelan ini mencegah Kubernetes mengalokasikan port node ke Layanan LoadBalancer. Untuk mengetahui informasi selengkapnya, lihat Menonaktifkan alokasi NodePort load balancer dalam dokumentasi Kubernetes.

Berikut adalah manifes untuk membuat Layanan yang tidak menggunakan port node apa pun:

apiVersion: v1
kind: Service
metadata:
  name: service-does-not-use-nodeports
spec:
  selector:
    app: my-app
  type: LoadBalancer
  ports:
  - port: 8000
  # Set allocateLoadBalancerNodePorts to false
  allocateLoadBalancerNodePorts: false

Menghapus Service Anda

Untuk menghapus Service Anda:

Gunakan kubectl delete untuk menghapus Layanan dari cluster Anda:

kubectl delete service my-service --kubeconfig CLUSTER_KUBECONFIG

Pastikan bahwa Layanan Anda telah dihapus:
```
kubectl get services --kubeconfig CLUSTER_KUBECONFIG
```
Output tidak lagi menampilkan my-service.

Menghapus Deployment

Untuk menghapus Deployment:

Gunakan kubectl delete untuk menghapus Deployment dari cluster Anda:
```
kubectl delete deployment my-deployment --kubeconfig CLUSTER_KUBECONFIG
```
Pastikan Deployment Anda telah dihapus:
```
kubectl get deployments --kubeconfig CLUSTER_KUBECONFIG
```
Output tidak lagi menampilkan my-deployment.

Langkah berikutnya

Membuat Layanan dan Ingress