Halaman ini diterjemahkan oleh Cloud Translation API.

Menyiapkan Deployment kube-dns kustom

Standard

Dokumen ini menjelaskan cara menyesuaikan penyiapan DNS di cluster Standar Google Kubernetes Engine (GKE) dengan mengganti kube-dns yang dikelola GKE dan merupakan default dengan deployment Anda sendiri. Tindakan ini memberi Anda lebih banyak kontrol atas penyedia DNS cluster Anda. Misalnya, Anda dapat:

Sesuaikan resource CPU dan memori untuk komponen DNS.
Gunakan versi image kube-dns tertentu.
Deploy penyedia DNS alternatif, seperti CoreDNS, yang mematuhi spesifikasi DNS Kubernetes.

Dokumen ini hanya untuk cluster Standard; Google mengelola konfigurasi DNS di cluster Autopilot. Untuk pemahaman yang lebih mendalam tentang penyedia DNS di GKE, lihat Tentang penemuan layanan dan kube-dns.

Perhatian: Jika menjalankan deployment DNS kustom, Anda bertanggung jawab atas pemeliharaannya yang berkelanjutan. Hal ini mencakup memastikan image penampung kube-dns dan autoscaler diupdate ke versi dan patch keamanan terbaru. Untuk menemukan image terbaru yang direkomendasikan, periksa deployment kube-dns default di namespace kube-system pada cluster GKE.

Dokumen ini ditujukan untuk pengguna GKE, termasuk Developer, Admin, dan arsitek. Untuk mempelajari lebih lanjut peran umum dan contoh tugas di Google Cloud, lihat Peran dan tugas pengguna GKE Enterprise umum.

Dokumen ini mengasumsikan bahwa Anda sudah memahami hal-hal berikut:

Menyiapkan deployment kube-dns kustom

Bagian ini menjelaskan cara mengganti kube-dns yang dikelola GKE dengan deployment Anda sendiri.

Membuat dan men-deploy manifes kustom

Simpan manifes Deployment berikut sebagai custom-kube-dns.yaml. Manifes ini menggunakan kube-dns.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: DNS_DEPLOYMENT_NAME
  namespace: kube-system
  labels:
    k8s-app: kube-dns
  annotations:
    deployment.kubernetes.io/revision: "1"
spec:
  selector:
    matchLabels:
      k8s-app: kube-dns
  strategy:
    rollingUpdate:
      maxSurge: 10%
      maxUnavailable: 0
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        k8s-app: kube-dns
    spec:
      containers:
      - name: kubedns
        image: registry.k8s.io/dns/k8s-dns-kube-dns:1.22.28
        resources:
          limits:
            memory: '170Mi'
          requests:
            cpu: 100m
            memory: '70Mi'
        livenessProbe:
          httpGet:
            path: /healthcheck/kubedns
            port: 10054
            scheme: HTTP
          initialDelaySeconds: 60
          timeoutSeconds: 5
          successThreshold: 1
          failureThreshold: 5
        readinessProbe:
          httpGet:
            path: /readiness
            port: 8081
            scheme: HTTP
          initialDelaySeconds: 3
          timeoutSeconds: 5
        args:
        - --domain=cluster.local.
        - --dns-port=10053
        - --config-dir=/kube-dns-config
        - --v=2
        env:
        - name: PROMETHEUS_PORT
          value: "10055"
        ports:
        - containerPort: 10053
          name: dns-local
          protocol: UDP
        - containerPort: 10053
          name: dns-tcp-local
          protocol: TCP
        - containerPort: 10055
          name: metrics
          protocol: TCP
        volumeMounts:
        - name: kube-dns-config
          mountPath: /kube-dns-config
        securityContext:
          allowPrivilegeEscalation: false
          readOnlyRootFilesystem: true
          runAsUser: 1001
          runAsGroup: 1001
      - name: dnsmasq
        image: registry.k8s.io/dns/k8s-dns-dnsmasq-nanny:1.22.28
        livenessProbe:
          httpGet:
            path: /healthcheck/dnsmasq
            port: 10054
            scheme: HTTP
          initialDelaySeconds: 60
          timeoutSeconds: 5
          successThreshold: 1
          failureThreshold: 5
        args:
        - -v=2
        - -logtostderr
        - -configDir=/etc/k8s/dns/dnsmasq-nanny
        - -restartDnsmasq=true
        - --
        - -k
        - --cache-size=1000
        - --no-negcache
        - --dns-forward-max=1500
        - --log-facility=-
        - --server=/cluster.local/127.0.0.1#10053
        - --server=/in-addr.arpa/127.0.0.1#10053
        - --server=/ip6.arpa/127.0.0.1#10053
        ports:
        - containerPort: 53
          name: dns
          protocol: UDP
        - containerPort: 53
          name: dns-tcp
          protocol: TCP
        resources:
          requests:
            cpu: 150m
            memory: 20Mi
        volumeMounts:
        - name: kube-dns-config
          mountPath: /etc/k8s/dns/dnsmasq-nanny
        securityContext:
          capabilities:
            drop:
            - all
            add:
            - NET_BIND_SERVICE
            - SETGID
      - name: sidecar
        image: registry.k8s.io/dns/k8s-dns-sidecar:1.22.28
        livenessProbe:
          httpGet:
            path: /metrics
            port: 10054
            scheme: HTTP
          initialDelaySeconds: 60
          timeoutSeconds: 5
          successThreshold: 1
          failureThreshold: 5
        args:
        - --v=2
        - --logtostderr
        - --probe=kubedns,127.0.0.1:10053,kubernetes.default.svc.cluster.local,5,SRV
        - --probe=dnsmasq,127.0.0.1:53,kubernetes.default.svc.cluster.local,5,SRV
        ports:
        - containerPort: 10054
          name: metrics
          protocol: TCP
        resources:
          requests:
            memory: 20Mi
            cpu: 10m
        securityContext:
          allowPrivilegeEscalation: false
          readOnlyRootFilesystem: true
          runAsUser: 1001
          runAsGroup: 1001
      dnsPolicy: Default
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      serviceAccount: kube-dns
      serviceAccountName: kube-dns
      terminationGracePeriodSeconds: 30
      tolerations:
      - key: CriticalAddonsOnly
        operator: Exists
      volumes:
      - configMap:
          defaultMode: 420
          name: kube-dns
          optional: true
        name: kube-dns-config

Ganti DNS_DEPLOYMENT_NAME dengan nama Deployment DNS kustom Anda.

Terapkan manifes ke cluster:
```
kubectl create -f custom-kube-dns.yaml
```

Memperkecil `kube-dns` yang dikelola GKE

Untuk menghindari konflik, nonaktifkan Deployment kube-dns dan kube-dns-autoscaler yang dikelola GKE dengan menskalakannya ke nol replika:

kubectl scale deployment --replicas=0 kube-dns-autoscaler kube-dns --namespace=kube-system

Mengonfigurasi autoscaler kustom

kube-dns-autoscaler default hanya menskalakan Deployment kube-dns yang dikelola GKE. Jika penyedia DNS kustom Anda memerlukan penskalaan otomatis, Anda harus men-deploy autoscaler terpisah dan memberikan izin untuk mengubah Deployment DNS kustom Anda.

Buat manifes berikut dan simpan sebagai custom-dns-autoscaler.yaml.

apiVersion: v1
kind: ConfigMap
metadata:
  name: custom-dns-autoscaler
  namespace: kube-system
data:
  linear: |-
    {
      "coresPerReplica": 256,
      "nodesPerReplica": 16,
      "preventSinglePointFailure": true
    }
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: system:custom-dns-autoscaler
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: system:custom-dns-autoscaler
subjects:
- kind: ServiceAccount
  name: kube-dns-autoscaler
  namespace: kube-system
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: system:custom-dns-autoscaler
rules:
- apiGroups:
  - ""
  resources:
  - nodes
  verbs:
  - list
  - watch
- apiGroups:
  - apps
  resourceNames:
  - DNS_DEPLOYMENT_NAME
  resources:
  - deployments/scale
  verbs:
  - get
  - update
- apiGroups:
  - ""
  resources:
  - configmaps
  verbs:
  - get
  - create
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: custom-dns-autoscaler
  namespace: kube-system
  labels:
    k8s-app: custom-dns-autoscaler
spec:
  selector:
    matchLabels:
      k8s-app: custom-dns-autoscaler
  template:
    metadata:
      labels:
        k8s-app: custom-dns-autoscaler
    spec:
      priorityClassName: system-cluster-critical
      securityContext:
        seccompProfile:
          type: RuntimeDefault
        supplementalGroups: [ 65534 ]
        fsGroup: 65534
      nodeSelector:
        kubernetes.io/os: linux
      containers:
      - name: autoscaler
        image: registry.k8s.io/autoscaling/cluster-proportional-autoscaler:1.8.9
        resources:
          requests:
            cpu: "20m"
            memory: "10Mi"
        command:
        - /cluster-proportional-autoscaler
        - --namespace=kube-system
        - --configmap=custom-dns-autoscaler
        - --target=Deployment/DNS_DEPLOYMENT_NAME
        - --default-params={"linear":{"coresPerReplica":256,"nodesPerReplica":16,"preventSinglePointFailure":true}}
        - --logtostderr=true
        - --v=2
      tolerations:
      - key: "CriticalAddonsOnly"
        operator: "Exists"
      serviceAccountName: kube-dns-autoscaler

Ganti DNS_DEPLOYMENT_NAME di kolom resourceNames dan di kolom command dengan nama Deployment DNS kustom Anda.

Terapkan manifes ke cluster:

kubectl create -f custom-dns-autoscaler.yaml

Memverifikasi deployment

Pastikan Pod DNS kustom Anda berjalan:

kubectl get pods -n kube-system -l k8s-app=kube-dns

Karena Anda menskalakan deployment kube-dns yang dikelola GKE menjadi nol replika, hanya Pod dari Deployment kustom Anda yang muncul di output. Verifikasi bahwa statusnya adalah Running.

Memulihkan kube-dns yang dikelola GKE

Jika Anda men-deploy konfigurasi kube-dns kustom dan perlu kembali ke penyiapan yang dikelola GKE default, Anda harus menghapus resource kustom dan mengaktifkan kembali deployment kube-dns terkelola.

Ikuti langkah-langkah berikut untuk memulihkan kube-dns yang dikelola GKE:

Hapus deployment kube-dns kustom dan penskala otomatisnya. Jika Anda menyimpan manifes sebagai custom-kube-dns.yaml dan custom-dns-autoscaler.yaml, jalankan perintah berikut untuk menghapus resource:
```
kubectl delete -f custom-dns-autoscaler.yaml
kubectl delete -f custom-kube-dns.yaml
```
Jika Anda tidak menyimpan manifes, hapus secara manual Deployment, ClusterRole, dan ClusterRoleBinding yang Anda buat untuk deployment kustom.
Pulihkan kube-dns-autoscaler yang dikelola GKE. Jalankan perintah berikut untuk menskalakan kembali deployment kube-dns-autoscaler menjadi satu replika:
```
kubectl scale deployment --replicas=1 kube-dns-autoscaler --namespace=kube-system
```
Perintah ini mengaktifkan kembali kube-dns-autoscaler terkelola, yang kemudian menskalakan deployment kube-dns terkelola secara otomatis ke jumlah replika yang sesuai untuk ukuran cluster Anda.
Verifikasi pemulihan.

Periksa Pod kube-dns dan kube-dns-autoscaler untuk memastikan keduanya berjalan dengan benar:
```
kubectl get pods -n kube-system -l k8s-app=kube-dns
```
Output akan menunjukkan bahwa Pod kube-dns yang dikelola GKE berada dalam status Running.

Langkah berikutnya

Baca ringkasan tentang cara GKE menyediakan DNS terkelola.
Baca DNS untuk Service dan Pod untuk mengetahui ringkasan umum tentang cara penggunaan DNS di cluster Kubernetes.

Menyiapkan Deployment kube-dns kustom Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.