Memasukkan Data ke dalam Aplikasi

• 1: Mendefinisikan Perintah dan Argumen untuk sebuah Kontainer
• 2: Mendefinisikan Variabel Lingkungan untuk sebuah Kontainer
• 3: Mendistribusikan Kredensial dengan Aman Menggunakan Secret

1 - Mendefinisikan Perintah dan Argumen untuk sebuah Kontainer

Laman ini menunjukkan bagaimana cara mendefinisikan perintah-perintah dan argumen-argumen saat kamu menjalankan Container dalam sebuah Pod.

Sebelum kamu memulai

Kamu harus memiliki klaster Kubernetes, dan perangkat baris perintah kubectl juga harus dikonfigurasikan untuk berkomunikasi dengan klastermu. Jika kamu belum memiliki klaster, kamu dapat membuatnya dengan menggunakan minikube, atau kamu juga dapat menggunakan salah satu dari tempat mencoba Kubernetes berikut ini:

• Katacoda
• Bermain dengan Kubernetes

Mendefinisikan sebuah perintah dan argumen-argumen saat kamu membuat sebuah Pod

Saat kamu membuat sebuah Pod, kamu dapat mendefinisikan sebuah perintah dan argumen-argumen untuk Container-Container yang berjalan di dalam Pod. Untuk mendefinisikan sebuah perintah, sertakan bidang command di dalam berkas konfigurasi. Untuk mendefinisikan argumen-argumen untuk perintah, sertakan bidang args di dalam berkas konfigurasi. Perintah dan argumen-argumen yang telah kamu definisikan tidak dapat diganti setelah Pod telah terbuat.

Perintah dan argumen-argumen yang kamu definisikan di dalam berkas konfigurasi membatalkan perintah dan argumen-argumen bawaan yang disediakan oleh image Container. Jika kamu mendefinisikan argumen-argumen, tetapi tidak mendefinisikan sebuah perintah, perintah bawaan digunakan dengan argumen-argumen baru kamu.

Catatan: Bidang command menyerupai entrypoint di beberapa runtime Container. Merujuk pada catatan di bawah.

Pada latihan ini, kamu akan membuat sebuah Pod baru yang menjalankan sebuah Container. Berkas konfigurasi untuk Pod mendefinisikan sebuah perintah dan dua argumen:

pods/commands.yaml

apiVersion: v1
kind: Pod
metadata:
  name: command-demo
  labels:
    purpose: demonstrate-command
spec:
  containers:
  - name: command-demo-container
    image: debian
    command: ["printenv"]
    args: ["HOSTNAME", "KUBERNETES_PORT"]
  restartPolicy: OnFailure

1. Buat sebuah Pod dengan berkas konfigurasi YAML:

   kubectl apply -f https://k8s.io/examples/pods/commands.yaml
   

2. Daftar Pod yang sedang berjalan

   kubectl get pods
   

   Keluaran menunjukkan bahwa Container yang berjalan di dalam Pod command-demo telah selesai.

3. Untuk melihat keluaran dari perintah yang berjalan di dalam Container, lihat log dari Pod tersebut:

   kubectl logs command-demo
   

   Keluaran menunjukan nilai dari variabel lingkungan HOSTNAME dan KUBERNETES_PORT:

   command-demo
   tcp://10.3.240.1:443
   

Menggunakan variabel lingkungan untuk mendefinisikan argumen

Dalam contoh sebelumnya, kamu mendefinisikan langsung argumen-argumen dengan menyediakan string. Sebagai sebuah alternatif untuk menyediakan string secara langsung, kamu dapat mendefinisikan argumen-argumen dengan menggunakan variabel lingkungan:

env:
- name: MESSAGE
  value: "hello world"
command: ["/bin/echo"]
args: ["$(MESSAGE)"]

Ini berarti kamu dapat mendefinisikan sebuah argumen untuk sebuah Pod menggunakan salah satu teknik yang tersedia untuk mendefinisikan variabel-variabel lingkungan, termasuk ConfigMap dan Secret.

Catatan: Variabel lingkugan muncul dalam tanda kurung, "$(VAR)". Ini dibutuhkan untuk variabel yang akan diperuluas di bidang command atau args.

Menjalankan sebuah perintah di dalam shell

Di beberapa kasus, kamu butuh perintah untuk menjalankan sebuah shell. Contohnya, perintah kamu mungkin terdiri dari beberapa perintah yang digabungkan, atau mungkin berupa skrip shell. Untuk menjalankan perintah kamu di sebuah shell, bungkus seperti ini:

command: ["/bin/sh"]
args: ["-c", "while true; do echo hello; sleep 10;done"]

Catatan

Tabel ini merangkum nama-nama bidang yang digunakan oleh Docker dan Kubernetes.

Saat kamu mengesampingkan Entrypoint dan Cmd standar, aturan-aturan ini berlaku:

• Jika kamu tidak menyediakan command atau args untuk sebuah Container, maka command dan args yang didefinisikan di dalam image Docker akan digunakan.

• Jika kamu menyediakan command tetapi tidak menyediakan args untuk sebuah Container, akan digunakan command yang disediakan. Entrypoint dan Cmd bawaan yang didefinisikan di dalam image Docker diabaikan.

• Jika kamu hanya menyediakan args untuk sebuah Container, Entrypoint bawaan yang didefinisikan di dalam image Docker dijalakan dengan args yang kamu sediakan.

• Jika kamu menyediakan command dan args, Entrypoint dan Cmd standar yang didefinisikan di dalam image Docker diabaikan. command kamu akan dijalankan dengan args kamu.

Berikut ini beberapa contoh:

Selanjutnya

• Pelajari lebih lanjut tentang mengatur Pod and Container.
• Pelajari lebih lanjut tentang menjalankan perintah di dalam sebuah Container.
• Lihat Container.

2 - Mendefinisikan Variabel Lingkungan untuk sebuah Kontainer

Laman ini menunjukkan bagaimana cara untuk mendefinisikan variabel lingkungan (environment variable) untuk sebuah Container di dalam sebuah Pod Kubernetes.

Sebelum kamu memulai

Kamu harus memiliki klaster Kubernetes, dan perangkat baris perintah kubectl juga harus dikonfigurasikan untuk berkomunikasi dengan klastermu. Jika kamu belum memiliki klaster, kamu dapat membuatnya dengan menggunakan minikube, atau kamu juga dapat menggunakan salah satu dari tempat mencoba Kubernetes berikut ini:

• Katacoda
• Bermain dengan Kubernetes

Mendefinisikan sebuah variabel lingkungan untuk sebuah Container

Ketika kamu membuat sebuah Pod, kamu dapat mengatur variabel lingkungan untuk Container-Container yang berjalan di dalam sebuah Pod. Untuk mengatur variabel lingkungan, sertakan bagian env atau envFrom pada berkas konfigurasi.

Dalam latihan ini, kamu membuat sebuah Pod yang menjalankan satu buah Container. Berkas konfigurasi untuk Pod tersebut mendefinisikan sebuah variabel lingkungan dengan nama DEMO_GREETING yang bernilai "Hello from the environment". Berikut berkas konfigurasi untuk Pod tersebut:

pods/inject/envars.yaml

apiVersion: v1
kind: Pod
metadata:
  name: envar-demo
  labels:
    purpose: demonstrate-envars
spec:
  containers:
  - name: envar-demo-container
    image: gcr.io/google-samples/node-hello:1.0
    env:
    - name: DEMO_GREETING
      value: "Hello from the environment"
    - name: DEMO_FAREWELL
      value: "Such a sweet sorrow"

1. Buatlah sebuah Pod berdasarkan berkas konfigurasi YAML tersebut:

   kubectl apply -f https://k8s.io/examples/pods/inject/envars.yaml
   

2. Tampilkan Pod-Pod yang sedang berjalan:

   kubectl get pods -l purpose=demonstrate-envars
   

   Keluarannya mirip seperti ini:

   NAME            READY     STATUS    RESTARTS   AGE
   envar-demo      1/1       Running   0          9s
   

3. Dapatkan sebuah shell ke Container yang sedang berjalan di Pod kamu:

   kubectl exec -it envar-demo -- /bin/bash
   

4. Di shell kamu, jalankan perintah printenv untuk melihat daftar variabel lingkungannya.

   root@envar-demo:/# printenv
   

   Keluarannya mirip seperti ini:

   NODE_VERSION=4.4.2
   EXAMPLE_SERVICE_PORT_8080_TCP_ADDR=10.3.245.237
   HOSTNAME=envar-demo
   ...
   DEMO_GREETING=Hello from the environment
   DEMO_FAREWELL=Such a sweet sorrow
   

5. Untuk keluar dari shell tersebut, masukkan perintah exit.

Catatan: Variabel-variabel lingkungan yang diatur menggunakan bagian env atau envFrom akan mengesampingkan variabel-variabel lingkungan yang ditentukan di dalam image kontainer.

Menggunakan variabel-variabel lingkungan di dalam konfigurasi kamu

Variabel-variabel lingkungan yang kamu definisikan di dalam sebuah konfigurasi Pod dapat digunakan di tempat lain dalam konfigurasi, contohnya di dalam perintah-perintah dan argumen-argumen yang kamu atur dalam Container-Container milik Pod. Pada contoh konfigurasi berikut, variabel-variabel lingkungan GREETING, HONORIFIC, dan NAME disetel masing-masing menjadi Warm greetings to, The Most Honorable, dan Kubernetes. Variabel-variabel lingkungan tersebut kemudian digunakan dalam argumen CLI yang diteruskan ke Container env-print-demo.

apiVersion: v1
kind: Pod
metadata:
  name: print-greeting
spec:
  containers:
  - name: env-print-demo
    image: bash
    env:
    - name: GREETING
      value: "Warm greetings to"
    - name: HONORIFIC
      value: "The Most Honorable"
    - name: NAME
      value: "Kubernetes"
    command: ["echo"]
    args: ["$(GREETING) $(HONORIFIC) $(NAME)"]

Setelah dibuat, perintah echo Warm greetings to The Most Honorable Kubernetes dijalankan di Container tersebut.

Selanjutnya

• Pelajari lebih lanjut tentang variabel lingkungan.
• Pelajari tentang menggunakan informasi rahasia sebagai variabel lingkungan.
• Lihat EnvVarSource.

3 - Mendistribusikan Kredensial dengan Aman Menggunakan Secret

Laman ini menjelaskan bagaimana cara menginjeksi data sensitif, seperti kata sandi (password) dan kunci enkripsi, ke dalam Pod.

Sebelum kamu memulai

Kamu harus memiliki klaster Kubernetes, dan perangkat baris perintah kubectl juga harus dikonfigurasikan untuk berkomunikasi dengan klastermu. Jika kamu belum memiliki klaster, kamu dapat membuatnya dengan menggunakan minikube, atau kamu juga dapat menggunakan salah satu dari tempat mencoba Kubernetes berikut ini:

• Katacoda
• Bermain dengan Kubernetes

Mengubah data rahasia kamu ke dalam representasi Base64

Misalnya kamu mempunyai dua buah data rahasia: sebuah nama pengguna my-app dan kata sandi 39528$vdg7Jb. Pertama, gunakan alat penyandian Base64 untuk mengubah nama pengguna kamu dan kata sandi ke dalam representasi Base64. Berikut ini contoh menggunakan program Base64 yang umum digunakan:

echo -n 'my-app' | base64
echo -n '39528$vdg7Jb' | base64

Hasil keluaran menampilkan representasi Base64 dari nama pengguna kamu yaitu bXktYXBw, dan representasi Base64 dari kata sandi kamu yaitu Mzk1MjgkdmRnN0pi.

Perhatian: Gunakan alat yang telah dipercayai oleh OS kamu untuk menghindari risiko dari penggunaan alat eksternal.

Membuat Secret

Berikut ini adalah berkas konfigurasi yang dapat kamu gunakan untuk membuat Secret yang akan menampung nama pengguna dan kata sandi kamu:

pods/inject/secret.yaml

apiVersion: v1
kind: Secret
metadata:
  name: test-secret
data:
  username: bXktYXBw
  password: Mzk1MjgkdmRnN0pi

1. Membuat Secret

   kubectl apply -f https://k8s.io/examples/pods/inject/secret.yaml
   

2. Melihat informasi dari Secret:

   kubectl get secret test-secret
   

   Hasil keluaran:

   NAME          TYPE      DATA      AGE
   test-secret   Opaque    2         1m
   

3. Melihat informasi detil dari Secret:

   kubectl describe secret test-secret
   

   Hasil keluaran:

   Name:       test-secret
   Namespace:  default
   Labels:     <none>
   Annotations:    <none>
   
   Type:   Opaque
   
   Data
   ====
   password:   13 bytes
   username:   7 bytes
   

Membuat Secret langsung dengan kubectl

Jika kamu ingin melompati langkah penyandian dengan Base64, kamu dapat langsung membuat Secret yang sama dengan menggunakan perintah kubectl create secret. Contohnya:

kubectl create secret generic test-secret --from-literal='username=my-app' --from-literal='password=39528$vdg7Jb'

Tentu saja ini lebih mudah. Pendekatan yang mendetil setiap langkah di atas bertujuan untuk mendemonstrasikan apa yang sebenarnya terjadi pada setiap langkah.

Membuat Pod yang memiliki akses ke data Secret melalui Volume

Berikut ini adalah berkas konfigurasi yang dapat kamu gunakan untuk membuat Pod:

pods/inject/secret-pod.yaml

apiVersion: v1
kind: Pod
metadata:
  name: secret-test-pod
spec:
  containers:
    - name: test-container
      image: nginx
      volumeMounts:
        # nama harus sesuai dengan nama Volume di bawah ini
        - name: secret-volume
          mountPath: /etc/secret-volume
  # Data Secret diekspos ke Container di dalam Pod melalui Volume
  volumes:
    - name: secret-volume
      secret:
        secretName: test-secret

1. Membuat Pod:

   kubectl apply -f https://k8s.io/examples/pods/inject/secret-pod.yaml
   

2. Verifikasikan apakah Pod kamu sudah berjalan:

   kubectl get pod secret-test-pod
   

   Hasil keluaran:

   NAME              READY     STATUS    RESTARTS   AGE
   secret-test-pod   1/1       Running   0          42m
   

3. Gunakan shell untuk masuk ke dalam Container yang berjalan di dalam Pod kamu:

   kubectl exec -i -t secret-test-pod -- /bin/bash
   

4. Data Secret terekspos ke Container melalui Volume yang dipasang (mount) pada /etc/secret-volume.

   Di dalam shell kamu, tampilkan berkas yang ada di dalam direktori /etc/secret-volume:

   # Jalankan ini di dalam shell dalam Container
   ls /etc/secret-volume
   

   Hasil keluaran menampilkan dua buah berkas, masing-masing untuk setiap data Secret:

   password username
   

5. Di dalam shell kamu, tampilkan konten dari berkas username dan password:

   # Jalankan ini di dalam shell dalam Container
   echo "$( cat /etc/secret-volume/username )"
   echo "$( cat /etc/secret-volume/password )"
   

   Hasil keluarannya adalah nama pengguna dan kata sandi kamu:

   my-app
   39528$vdg7Jb
   

Mendefinisikan variabel lingkungan Container menggunakan data Secret

Mendefinisikan variabel lingkungan Container menggunakan data dari Secret tunggal

• Definisikan variabel lingkungan sebagai pasangan key-value pada Secret:

  kubectl create secret generic backend-user --from-literal=backend-username='backend-admin'
  

• Tentukan nilai backend-username yang didefinisikan di Secret ke variabel lingkungan SECRET_USERNAME di dalam spesifikasi Pod.

  pods/inject/pod-single-secret-env-variable.yaml

  apiVersion: v1
  kind: Pod
  metadata:
    name: env-single-secret
  spec:
    containers:
    - name: envars-test-container
      image: nginx
      env:
      - name: SECRET_USERNAME
        valueFrom:
          secretKeyRef:
            name: backend-user
            key: backend-username
  

• Membuat Pod:

  kubectl create -f https://k8s.io/examples/pods/inject/pod-single-secret-env-variable.yaml
  

• Di dalam shell kamu, tampilkan konten dari variabel lingkungan SECRET_USERNAME dari Container

  kubectl exec -i -t env-single-secret -- /bin/sh -c 'echo $SECRET_USERNAME'
  

  Hasil keluarannya

  backend-admin
  

Mendefinisikan variabel lingkungan Container dengan data dari multipel Secret

• Seperti contoh sebelumnya, buat Secret terlebih dahulu.

  kubectl create secret generic backend-user --from-literal=backend-username='backend-admin'
  kubectl create secret generic db-user --from-literal=db-username='db-admin'
  

• Definisikan variabel lingkungan di dalam spesifikasi Pod.

  pods/inject/pod-multiple-secret-env-variable.yaml

  apiVersion: v1
  kind: Pod
  metadata:
    name: envvars-multiple-secrets
  spec:
    containers:
    - name: envars-test-container
      image: nginx
      env:
      - name: BACKEND_USERNAME
        valueFrom:
          secretKeyRef:
            name: backend-user
            key: backend-username
      - name: DB_USERNAME
        valueFrom:
          secretKeyRef:
            name: db-user
            key: db-username
  

• Membuat Pod:

  kubectl create -f https://k8s.io/examples/pods/inject/pod-multiple-secret-env-variable.yaml
  

• Di dalam shell kamu, tampilkan konten dari variabel lingkungan Container

  kubectl exec -i -t envvars-multiple-secrets -- /bin/sh -c 'env | grep _USERNAME'
  

  Hasil keluarannya

  DB_USERNAME=db-admin
  BACKEND_USERNAME=backend-admin
  

Mengonfigurasi semua pasangan key-value di dalam Secret sebagai variabel lingkungan Container

Catatan: Fitur ini tersedia mulai dari Kubernetes v1.6 dan yang lebih baru.

• Membuat Secret yang berisi banyak pasangan key-value

  kubectl create secret generic test-secret --from-literal=username='my-app' --from-literal=password='39528$vdg7Jb'
  

• Gunakan envFrom untuk mendefinisikan semua data Secret sebagai variabel lingkungan Container. Key dari Secret akan mennjadi nama variabel lingkungan di dalam Pod.

  pods/inject/pod-secret-envFrom.yaml

  apiVersion: v1
  kind: Pod
  metadata:
    name: envfrom-secret
  spec:
    containers:
    - name: envars-test-container
      image: nginx
      envFrom:
      - secretRef:
          name: test-secret
  

• Membuat Pod:

  kubectl create -f https://k8s.io/examples/pods/inject/pod-secret-envFrom.yaml
  

• Di dalam shell kamu, tampilkan variabel lingkungan Container username dan password

  kubectl exec -i -t envfrom-secret -- /bin/sh -c 'echo "username: $username\npassword: $password\n"'
  

  Hasil keluarannya

  username: my-app
  password: 39528$vdg7Jb
  

Referensi

• Secret
• Volume
• Pod

Selanjutnya

• Pelajari lebih lanjut Secret.
• Pelajari lebih lanjut Volume.