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

1. मकसद

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

इस ट्यूटोरियल में, आपने Skofold के कुछ मुख्य सिद्धांतों पर काम किया है. अपने इनर डेवलपमेंट लूप को ऑटोमेट करने के बाद, कोई ऐप्लिकेशन डिप्लॉय किया जा सकता है.

ऐसा करने पर:

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

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

आपका फ़ाइल फ़ोल्डर तैयार किया जा रहा है

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

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. यहां दिए गए कमांड की मदद से, अपने क्लाउड शेल फ़ाइल फ़ोल्डर को मौजूदा डायरेक्ट्री पर सेट करें:

cloudshell workspace .

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

1. नीचे दिए गए निर्देश की मदद से, पक्का करें कि आपका Google Cloud प्रोजेक्ट सही तरीके से सेट हो:

gcloud config set project {{project-id}}

3. स्केलोल्ड के साथ शुरुआत करें

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 फ़ाइल को IDE पैनल में खोलें. यह टॉप-लेवल की कॉन्फ़िगरेशन फ़ाइल है, जो Skaffold पाइपलाइन के बारे में बताती है.

YAML में Kubernetes जैसे YAML फ़ॉर्मैट और यहां दिए गए सेक्शन पर ध्यान दें:

• build
• deploy
• profiles

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

स्कैफ़ोल्ड पाइपलाइन स्टेज से जुड़े दस्तावेज़ में, स्कैफ़ोल्ड के स्टेज की पूरी सूची के बारे में और पढ़ा जा सकता है.

4. बनाएं

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

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

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

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

Kustomize टूल, एक या एक से ज़्यादा "ओवरले" के साथ सामान्य कॉम्पोनेंट YAML फ़ाइलों (base डायरेक्ट्री में) के सेट को जोड़कर, Kubernetes मेनिफ़ेस्ट जनरेट करने की सुविधा देता है जो आम तौर पर एक या ज़्यादा डिप्लॉयमेंट टारगेट से जुड़ी होती हैं – आम तौर पर, ये डेव, टेस्ट, स्टेजिंग, और प्रोडक्शन या इससे मिलते-जुलते होते हैं.

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

6. प्रोफ़ाइल

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

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

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

ऐप्लिकेशन के सोर्स कोड पर जाना.

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

Dockerfile देखना

1. app > Dockerfile फ़ाइल को IDE पैनल में खोलें. इस फ़ाइल में main.go फ़ाइल के लिए ऐप्लिकेशन कंटेनर इमेज बनाने के निर्देशों का क्रम शामिल है और इसका संदर्भ टॉप लेवल की skaffold.yaml फ़ाइल में दिया गया है.

7. स्केलोल्ड के साथ डेवलप करना

अपने 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

स्थानीय विकास के लिए स्केफ़ोल्ड का इस्तेमाल करना

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

skaffold dev

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

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

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

ऐप्लिकेशन में बदलाव करना

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

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

"Hello world from pod %s!\n"

इससे बदलें:

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

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

2. अब, "app > main.go" IDE पैनल में, लाइन बदलें:

time.Sleep(time.Second * 1)

से

time.Sleep(time.Second * 10)

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

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

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

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

replicas: 1

से

replicas: 2

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

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

replicas: 1

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

3. आखिर में, स्केलोल्ड के लोकल डेवलपमेंट को रोकने के लिए, टर्मिनल विंडो में 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. स्कैफ़ोल्ड आउटपुट को बंद करने के लिए, टर्मिनल विंडो में 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. स्कैफ़ोल्ड आउटपुट को बंद करने के लिए, टर्मिनल विंडो में 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 को कॉन्फ़िगर कैसे करें और उनका इस्तेमाल कैसे करें.

आने वाले समय में मिलने वाली सुविधाएं:

स्केलोल्ड के बारे में ज़्यादा जानें:

• स्कैफ़ोल्ड की डीप डाइव

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

1. लोकल क्लस्टर शट डाउन करने के लिए ये निर्देश चलाएं:

minikube delete