Memasukkan Data ke dalam Aplikasi

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:

Untuk melihat versi, tekan kubectl version.

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

Buat sebuah Pod dengan berkas konfigurasi YAML:

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

Daftar Pod yang sedang berjalan
```
kubectl get pods
```
Keluaran menunjukkan bahwa Container yang berjalan di dalam Pod command-demo telah selesai.
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.

Deskripsi	Nama bidang pada Docker	Nama bidang pada Kubernetes
Perintah yang dijalankan oleh Container	Entrypoint	command
Argumen diteruskan ke perintah	Cmd	args

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:

Image Entrypoint	Image Cmd	Container command	Container args	Command run
`[/ep-1]`	`[foo bar]`	<not set>	<not set>	`[ep-1 foo bar]`
`[/ep-1]`	`[foo bar]`	`[/ep-2]`	<not set>	`[ep-2]`
`[/ep-1]`	`[foo bar]`	<not set>	`[zoo boo]`	`[ep-1 zoo boo]`
`[/ep-1]`	`[foo bar]`	`[/ep-2]`	`[zoo boo]`	`[ep-2 zoo boo]`

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

Untuk melihat versi, tekan kubectl version.

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"

Buatlah sebuah Pod berdasarkan berkas konfigurasi YAML tersebut:

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

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

Dapatkan sebuah shell ke Container yang sedang berjalan di Pod kamu:
```
kubectl exec -it envar-demo -- /bin/bash
```

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

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

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

Membuat Secret

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

Melihat informasi dari Secret:

kubectl get secret test-secret

Hasil keluaran:

NAME          TYPE      DATA      AGE
test-secret   Opaque    2         1m

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

Membuat Pod:

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

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

Gunakan shell untuk masuk ke dalam Container yang berjalan di dalam Pod kamu:
```
kubectl exec -i -t secret-test-pod -- /bin/bash
```
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
```

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

Selanjutnya

Pelajari lebih lanjut Secret.
Pelajari lebih lanjut Volume.