स्कैफ़ोल्ड को समझना

1. मकसद

Skaffold एक ऐसा टूल है जो आपके ऐप्लिकेशन को बनाने, पुश करने, और डिप्लॉय करने के वर्कफ़्लो को मैनेज करता है. Skaffold का इस्तेमाल करके, लोकल डेवलपमेंट वर्कस्पेस को आसानी से कॉन्फ़िगर किया जा सकता है. साथ ही, अपने डेवलपमेंट लूप को बेहतर बनाया जा सकता है. इसके अलावा, इसे Kustomize और Helm जैसे अन्य टूल के साथ इंटिग्रेट किया जा सकता है. इससे आपको Kubernetes मेनिफ़ेस्ट मैनेज करने में मदद मिलती है.

इस ट्यूटोरियल में, Skaffold के कुछ मुख्य कॉन्सेप्ट के बारे में बताया गया है. साथ ही, इसका इस्तेमाल करके, डेवलपमेंट लूप को ऑटोमेट करने और ऐप्लिकेशन को डिप्लॉय करने का तरीका बताया गया है.

आपको:

• लोकल डेवलपमेंट के लिए Skaffold को कॉन्फ़िगर और चालू करना
• एक सामान्य golang ऐप्लिकेशन बनाना और उसे चलाना
• Skaffold की मदद से, लोकल ऐप्लिकेशन डिप्लॉयमेंट मैनेज करना
• मेनिफ़ेस्ट रेंडर करना और ऐप्लिकेशन डिप्लॉय करना

2. शुरू करने से पहले

आपका Workspace खाता तैयार किया जा रहा है

1. इस यूआरएल पर जाकर, Cloud Shell एडिटर खोलें:

https://shell.cloud.google.com

तीसरे पक्ष की कुकी को अनुमति दें. "साइट काम नहीं कर रही है" पर क्लिक करें. इसके बाद, "कुकी की अनुमति दें" पर क्लिक करें.

2. अगर आपने पहले से ऐसा नहीं किया है, तो टर्मिनल विंडो में, इस कमांड का इस्तेमाल करके ऐप्लिकेशन सोर्स को क्लोन करें:

git clone https://github.com/GoogleCloudPlatform/software-delivery-workshop.git

3. क्लोन की गई रिपॉज़िटरी डायरेक्ट्री में जाएं:

cd software-delivery-workshop/labs/understanding-skaffold/getting-started

4. Cloud Shell वर्कस्पेस को मौजूदा डायरेक्ट्री पर सेट करने के लिए, यह निर्देश चलाएं:

cloudshell workspace .

आपका प्रोजेक्ट तैयार किया जा रहा है

1. पक्का करें कि आपका Google Cloud प्रोजेक्ट सही तरीके से सेट किया गया हो. इसके लिए, यह कमांड चलाएं:

gcloud config set project {{project-id}}

3. Skaffold का इस्तेमाल शुरू करना

1. टॉप-लेवल की Skaffold कॉन्फ़िगरेशन फ़ाइल, skaffold.yaml बनाने के लिए, यह कमांड चलाएं:

cat <<EOF > skaffold.yaml
apiVersion: skaffold/v2beta21
kind: Config
metadata:
  name: getting-started-kustomize
build:
  tagPolicy:
    gitCommit:
      ignoreChanges: true
  artifacts:
  - image: skaffold-kustomize
    context: app
    docker:
      dockerfile: Dockerfile
deploy:
  kustomize:
    paths:
    - overlays/dev
profiles:
- name: staging
  deploy:
    kustomize:
      paths:
      - overlays/staging
- name: prod
  deploy:
    kustomize:
      paths:
      - overlays/prod
EOF

2. आईडीई पैन में skaffold.yaml फ़ाइल खोलें. यह टॉप-लेवल की कॉन्फ़िगरेशन फ़ाइल है, जो Skaffold पाइपलाइन के बारे में बताती है.

Kubernetes जैसे YAML फ़ॉर्मैट और YAML में मौजूद इन सेक्शन पर ध्यान दें:

• build
• deploy
• profiles

इन सेक्शन में, ऐप्लिकेशन को बनाने और डिप्लॉय करने का तरीका बताया गया है. साथ ही, हर डिप्लॉयमेंट टारगेट के लिए प्रोफ़ाइलें भी दी गई हैं.

Skaffold के सभी चरणों की सूची के बारे में ज़्यादा जानने के लिए, Skaffold Pipeline Stages का दस्तावेज़ पढ़ें.

4. बनाएं

build सेक्शन में कॉन्फ़िगरेशन होता है. इससे यह तय होता है कि ऐप्लिकेशन को कैसे बनाया जाना चाहिए. इस मामले में, आपको यह कॉन्फ़िगरेशन दिखेगा कि git टैग को कैसे हैंडल किया जाना चाहिए. साथ ही, एक artifacts सेक्शन दिखेगा, जिसमें ऐप्लिकेशन में शामिल कंटेनर इमेज के बारे में बताया गया है.

इसके अलावा, इस सेक्शन में आपको इमेज बनाने के लिए इस्तेमाल किए जाने वाले Dockerfile का रेफ़रंस भी दिखेगा. Skaffold, Jib, Maven, Gradle, क्लाउड-नेटिव Buildpacks, Bazel, और कस्टम स्क्रिप्ट जैसे अन्य बिल्ड टूल के साथ भी काम करता है. इस कॉन्फ़िगरेशन के बारे में ज़्यादा जानने के लिए, Skaffold Build का दस्तावेज़ पढ़ें.

5. डिप्लॉय करें

deploy सेक्शन में कॉन्फ़िगरेशन होता है. इससे यह तय होता है कि ऐप्लिकेशन को कैसे डिप्लॉय किया जाना चाहिए. इस मामले में, डिफ़ॉल्ट डिप्लॉयमेंट का एक उदाहरण देखा जा सकता है. यह Skaffold को Kustomize टूल का इस्तेमाल करने के लिए कॉन्फ़िगर करता है.

Kustomize टूल, Kubernetes मेनिफ़ेस्ट जनरेट करने की सुविधा देता है. इसके लिए, यह टूल base डायरेक्ट्री में मौजूद कॉम्पोनेंट की सामान्य YAML फ़ाइलों के सेट को एक या उससे ज़्यादा "ओवरले" के साथ जोड़ता है. आम तौर पर, ये ओवरले एक या उससे ज़्यादा डिप्लॉयमेंट टारगेट से जुड़े होते हैं. जैसे, dev, test, staging, production या इसी तरह के अन्य टारगेट.

इस उदाहरण में, तीन टारगेट के लिए दो ओवरले दिखाए गए हैं: dev, staging, और prod. dev ओवरले का इस्तेमाल लोकल डेवलपमेंट के दौरान किया जाएगा. वहीं, Skaffold का इस्तेमाल करके डिप्लॉय करने के दौरान staging और prod ओवरले का इस्तेमाल किया जाएगा.

6. प्रोफ़ाइलें

profiles सेक्शन में, अलग-अलग कॉन्टेक्स्ट के लिए बिल्ड, टेस्ट, और डिप्लॉयमेंट कॉन्फ़िगरेशन तय करने वाला कॉन्फ़िगरेशन होता है. अलग-अलग कॉन्टेक्स्ट, आम तौर पर आपके ऐप्लिकेशन डिप्लॉयमेंट पाइपलाइन में अलग-अलग एनवायरमेंट होते हैं. जैसे, इस उदाहरण में staging या prod. इसका मतलब है कि अब उन मेनिफ़ेस्ट को आसानी से मैनेज किया जा सकता है जिनके कॉन्टेंट को अलग-अलग टारगेट एनवायरमेंट के लिए अलग-अलग होना चाहिए. इसके लिए, आपको बॉयलरप्लेट कॉन्फ़िगरेशन को दोहराने की ज़रूरत नहीं होगी.

profiles सेक्शन में मौजूद कॉन्फ़िगरेशन, मुख्य कॉन्फ़िगरेशन (जैसे कि build, test या deploy सेक्शन) के किसी भी आइटम को बदल सकता है या उसमें बदलाव कर सकता है.

इसका एक उदाहरण देखने के लिए, फ़ाइल overlays > prod > deployment.yaml खोलें. ध्यान दें कि ऐप्लिकेशन के लिए रेप्लिका की संख्या को यहां तीन पर कॉन्फ़िगर किया गया है. इससे बेस कॉन्फ़िगरेशन बदल जाता है.

ऐप्लिकेशन के सोर्स कोड में एक जगह से दूसरी जगह जाना.

1. आईडीई पैन में, यह फ़ाइल app > main.go खोलें. यह एक सामान्य golang ऐप्लिकेशन है, जो हर सेकंड stdout में एक स्ट्रिंग लिखता है.
2. ध्यान दें कि ऐप्लिकेशन, उस Kubernetes पॉड का नाम भी दिखाता है जिसमें वह चल रहा है.

Dockerfile देखना

1. आईडीई पैन में app > Dockerfile फ़ाइल खोलें. इस फ़ाइल में, main.go फ़ाइल के लिए ऐप्लिकेशन कंटेनर इमेज बनाने के निर्देशों का क्रम होता है. साथ ही, इसे टॉप-लेवल की skaffold.yaml फ़ाइल में रेफ़र किया जाता है.

7. Skaffold की मदद से डेवलपमेंट करना

Kubernetes एनवायरमेंट को कॉन्फ़िगर करना

1. यह पक्का करने के लिए कि आपका लोकल Kubernetes क्लस्टर चल रहा है और कॉन्फ़िगर किया गया है, यहां दिया गया कमांड चलाएं:

minikube start

इसमें कुछ मिनट लग सकते हैं. अगर क्लस्टर चालू हो गया है, तो आपको यह आउटपुट दिखेगा:

Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default

2. dev, staging, और prod के लिए Kubernetes नेमस्पेस बनाने के लिए, यह निर्देश चलाएं:

kubectl apply -f namespaces.yaml

आपको यह आउटपुट दिखेगा:

namespace/dev created
namespace/staging created
namespace/prod created

लोकल डेवलपमेंट के लिए Skaffold का इस्तेमाल करना

1. ऐप्लिकेशन बनाने और उसे Cloud Shell में चल रहे लोकल Kubernetes क्लस्टर पर डिप्लॉय करने के लिए, यह कमांड चलाएं:

skaffold dev

आपको ऐप्लिकेशन कंटेनर बनाने की प्रोसेस चलती हुई दिखेगी. इसमें एक मिनट लग सकता है. इसके बाद, ऐप्लिकेशन का आउटपुट हर सेकंड में दिखेगा:

[skaffold-kustomize] Hello world from pod skaffold-kustomize-dev-xxxxxxxxx-xxxxx

ध्यान दें कि पॉड का सटीक नाम, ऊपर दिए गए सामान्य आउटपुट से अलग होगा.

आवेदन में बदलाव करना

अब ऐप्लिकेशन आपके लोकल Kubernetes क्लस्टर में चल रहा है. इसलिए, कोड में बदलाव किए जा सकते हैं. Skaffold, ऐप्लिकेशन को अपने-आप फिर से बनाएगा और उसे क्लस्टर में फिर से डिप्लॉय करेगा.

1. आईडीई पैन में app > main.go फ़ाइल खोलें और आउटपुट स्ट्रिंग बदलें:

"Hello world from pod %s!\n"

इससे बदलें:

"Hello Skaffold world from pod %s!\n"

बदलाव करने के बाद, आपको Skaffold को इमेज फिर से बनाने और उसे क्लस्टर में फिर से डिप्लॉय करते हुए देखना चाहिए. साथ ही, टर्मिनल विंडो में आउटपुट में बदलाव दिखना चाहिए.

2. अब IDE पैनल में मौजूद फ़ाइल "app > main.go" में भी, इस लाइन को बदलें:

time.Sleep(time.Second * 1)

से

time.Sleep(time.Second * 10)

आपको ऐप्लिकेशन को फिर से बनाया और फिर से डिप्लॉय किया गया दिखेगा. साथ ही, आउटपुट लाइन हर 10 सेकंड में दिखेगी.

Kubernetes के कॉन्फ़िगरेशन में बदलाव करना

इसके बाद, Kubernetes कॉन्फ़िगरेशन में बदलाव करें. Skaffold, बदलावों को अपने-आप फिर से डिप्लॉय कर देगा.

1. फ़ाइल base > deployment.yaml को आईडीई में खोलें और इस लाइन में बदलाव करें:

replicas: 1

से

replicas: 2

ऐप्लिकेशन को फिर से डिप्लॉय करने के बाद, आपको दो पॉड चलते हुए दिखेंगे. हर पॉड का नाम अलग होगा.

2. अब फ़ाइल base > deployment.yaml में मौजूद उसी लाइन को वापस इस तरह बदलें:

replicas: 1

आपको दिखेगा कि सेवा से एक पॉड हटा दिया गया है, ताकि सिर्फ़ एक पॉड बचा रहे.

3. आखिर में, Skaffold के लोकल डेवलपमेंट को रोकने के लिए, टर्मिनल विंडो में Ctrl-C दबाएं.

रिलीज़ को काटना

इसके बाद, रिलीज़ इमेज बनाकर और उसे क्लस्टर पर डिप्लॉय करके, एक रिलीज़ बनाई जाएगी.

1. रिलीज़ बनाने के लिए, यह कमांड चलाएं:

skaffold build --file-output artifacts.json

यह निर्देश, फ़ाइनल इमेज बनाएगा (अगर ज़रूरी हो). साथ ही, रिलीज़ की जानकारी को artifacts.json फ़ाइल में आउटपुट करेगा.

अगर आपको अपने क्लस्टर पर डिप्लॉय करने के लिए Cloud Deploy जैसे टूल का इस्तेमाल करना है, तो इस फ़ाइल में रिलीज़ की जानकारी होती है. इसका मतलब है कि लाइव होने के रास्ते में, आर्टफ़ैक्ट में बदलाव नहीं किया जा सकता.

2. artifacts.json फ़ाइल का कॉन्टेंट देखने के लिए, यह कमांड चलाएं:

cat artifacts.json | jq

ध्यान दें कि फ़ाइल में उस इमेज का रेफ़रंस होता है जिसका इस्तेमाल फ़ाइनल डिप्लॉयमेंट में किया जाएगा.

स्टेजिंग एनवायरमेंट में डिप्लॉय करना

1. staging प्रोफ़ाइल का इस्तेमाल करके रिलीज़ को डिप्लॉय करने के लिए, यह कमांड चलाएं:

skaffold deploy --profile staging --build-artifacts artifacts.json --tail

डप्लॉयमेंट पूरा होने के बाद, आपको दो पॉड से आउटपुट दिखेगा. यह आउटपुट कुछ इस तरह का होगा:

[skaffold-kustomize] Hello world from pod skaffold-kustomize-staging-xxxxxxxxxx-xxxxx!

2. Skaffold के आउटपुट को रोकने के लिए, टर्मिनल विंडो में Ctrl-C दबाएं.
3. अपने ऐप्लिकेशन को क्लस्टर में चालू और चालू रखने के लिए, यह कमांड चलाएं:

kubectl get all --namespace staging

आपको दो अलग-अलग पॉड के नाम दिखेंगे, क्योंकि ऐप्लिकेशन के लिए staging प्रोफ़ाइल में यह बताया गया है कि डिप्लॉयमेंट में दो रेप्लिका होने चाहिए.

प्रोडक्शन में डिप्लॉय करना

1. अब prod प्रोफ़ाइल का इस्तेमाल करके रिलीज़ को डिप्लॉय करने के लिए, यह कमांड चलाएं:

skaffold deploy --profile prod --build-artifacts artifacts.json --tail

डप्लॉयमेंट पूरा होने के बाद, आपको तीन पॉड से आउटपुट दिखेगा. यह आउटपुट कुछ इस तरह का होगा:

[skaffold-kustomize] Hello world from pod skaffold-kustomize-prod-xxxxxxxxxx-xxxxx!

2. Skaffold के आउटपुट को रोकने के लिए, टर्मिनल विंडो में Ctrl-C दबाएं.

आपको तीन अलग-अलग पॉड के नाम दिखेंगे, क्योंकि ऐप्लिकेशन के लिए prod प्रोफ़ाइल में यह बताया गया है कि डिप्लॉयमेंट में तीन रेप्लिका होने चाहिए.

3. अपने ऐप्लिकेशन को क्लस्टर में चालू और चालू रखने के लिए, यह कमांड चलाएं:

kubectl get all --namespace prod

आपको ऐसा आउटपुट दिखेगा जिसमें प्रॉडक्ट डिप्लॉयमेंट दिखाने वाली, यहां दी गई लाइनों जैसी लाइनें शामिल होंगी:

NAME                                      READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/skaffold-kustomize-prod   3/3     3            3           16m

आपको तीन ऐप्लिकेशन पॉड भी चलते हुए दिखने चाहिए.

NAME                                           READY   STATUS    RESTARTS   AGE
pod/skaffold-kustomize-prod-xxxxxxxxxx-xxxxx   1/1     Running   0          10m
pod/skaffold-kustomize-prod-xxxxxxxxxx-xxxxx   1/1     Running   0          10m
pod/skaffold-kustomize-prod-xxxxxxxxxx-xxxxx   1/1     Running   0          10m

8. बधाई हो!

बधाई हो! आपने Understanding Skaffold लैब पूरा कर लिया है. साथ ही, आपने लोकल डेवलपमेंट और ऐप्लिकेशन डिप्लॉयमेंट के लिए Skaffold को कॉन्फ़िगर करने और इस्तेमाल करने का तरीका जान लिया है.

इसके बाद क्या होगा:

Skaffold के बारे में ज़्यादा जानने के लिए, यहां जाएं:

• Skaffold के बारे में ज़्यादा जानें

साफ़-सफ़ाई सेवा

1. लोकल क्लस्टर को बंद करने के लिए, यह कमांड चलाएं:

minikube delete