Dockerफ़ाइलों के साथ कंटेनर बनाना

1. खास जानकारी

Docker, ऐप्लिकेशन डेवलप करने, शिप करने, और चलाने के लिए एक ओपन प्लैटफ़ॉर्म है. Docker की मदद से, अपने ऐप्लिकेशन को इंफ़्रास्ट्रक्चर से अलग किया जा सकता है. साथ ही, इंफ़्रास्ट्रक्चर को मैनेज किए जा सकने वाले ऐप्लिकेशन की तरह इस्तेमाल किया जा सकता है. Docker की मदद से, कोड को तेज़ी से शिप किया जा सकता है, तेज़ी से टेस्ट किया जा सकता है, और तेज़ी से डिप्लॉय किया जा सकता है. साथ ही, कोड लिखने और उसे चलाने के बीच के समय को कम किया जा सकता है.

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

Docker कंटेनर को सीधे तौर पर Kubernetes में इस्तेमाल किया जा सकता है. इससे उन्हें Kubernetes Engine में आसानी से चलाया जा सकता है. Docker के बारे में ज़रूरी जानकारी पाने के बाद, आपके पास Kubernetes और कंटेनर वाले ऐप्लिकेशन डेवलप करने के लिए ज़रूरी कौशल होगा.

आपको क्या सीखने को मिलेगा

इस लैब में, आपको ये काम करने का तरीका बताया जाएगा:

  • किसी सैंपल ऐप्लिकेशन के लिए Dockerfile बनाना
  • इमेज बनाना
  • इमेज को स्थानीय तौर पर कंटेनर के तौर पर चलाएं
  • कंटेनर के काम करने के तरीके में बदलाव करना
  • इमेज को Artifact Registry में पुश करें

ज़रूरी शर्तें

यह शुरुआती लेवल का लैब है. यह मान लिया जाता है कि आपको Docker और कंटेनर के बारे में बहुत कम जानकारी है या बिलकुल भी जानकारी नहीं है. हमारा सुझाव है कि आपको Cloud Shell और कमांड लाइन के बारे में जानकारी हो. हालांकि, ऐसा करना ज़रूरी नहीं है.

अपनी स्पीड से एनवायरमेंट सेट अप करना

  1. Google Cloud Console में साइन इन करें और नया प्रोजेक्ट बनाएं या किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल करें. अगर आपके पास पहले से कोई Gmail या Google Workspace खाता नहीं है, तो आपको एक खाता बनाना होगा.

b35bf95b8bf3d5d8.png

a99b7ace416376c4.png

bd84a6d3004737c5.png

  • प्रोजेक्ट का नाम, इस प्रोजेक्ट में हिस्सा लेने वाले लोगों के लिए डिसप्ले नेम होता है. यह एक कैरेक्टर स्ट्रिंग है, जिसका इस्तेमाल Google API नहीं करते. इसे किसी भी समय अपडेट किया जा सकता है.
  • प्रोजेक्ट आईडी, सभी Google Cloud प्रोजेक्ट के लिए यूनीक होना चाहिए. साथ ही, इसे बदला नहीं जा सकता. Cloud Console, एक यूनीक स्ट्रिंग अपने-आप जनरेट करता है. आम तौर पर, आपको इससे कोई फ़र्क़ नहीं पड़ता कि यह क्या है. ज़्यादातर कोडलैब में, आपको प्रोजेक्ट आईडी का रेफ़रंस देना होगा. इसे आम तौर पर PROJECT_ID के तौर पर पहचाना जाता है. इसलिए, अगर आपको यह पसंद नहीं है, तो कोई दूसरा रैंडम आईडी जनरेट करें. इसके अलावा, अपने हिसाब से कोई आईडी बनाकर देखें कि वह उपलब्ध है या नहीं. इसके बाद, प्रोजेक्ट बनाने के बाद इसे "फ़्रीज़" कर दिया जाता है.
  • तीसरी वैल्यू, प्रोजेक्ट नंबर होती है. इसका इस्तेमाल कुछ एपीआई करते हैं. इन तीनों वैल्यू के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.
  1. इसके बाद, आपको Cloud Console में बिलिंग चालू करनी होगी, ताकि Cloud संसाधनों/एपीआई का इस्तेमाल किया जा सके. इस कोडलैब को पूरा करने में ज़्यादा खर्च नहीं आएगा. संसाधन बंद करने के लिए, कोडलैब के आखिर में दिए गए "बंद करें" निर्देशों का पालन करें, ताकि इस ट्यूटोरियल के बाद आपको बिलिंग न करनी पड़े. Google Cloud के नए उपयोगकर्ताओं को, मुफ़्त में आज़माने के लिए 300 डॉलर का क्रेडिट मिलता है.

2. नमूना एप्लिकेशन

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

सोर्स कोड

इस लैब का सोर्स कोड, GoogleCloudPlatform/container-developer-workshop रिपॉज़िटरी में उपलब्ध है. साथ ही, सैंपल ऐप्लिकेशन का दस्तावेज़ भी उपलब्ध है.

Git कॉन्फ़िगर करना

git config --global user.name ${USER}
git config --global user.email ${USER}@qwiklabs.net

Cloud Source Repository से सैंपल ऐप्लिकेशन को क्लोन करना

gcloud source repos clone sample-app ${HOME}/sample-app &&
cd ${HOME}/sample-app &&
git checkout main

आउटपुट

Cloning into '/home/student_03_49720296e995/sample-app'...
remote: Finding sources: 100% (16/16)
remote: Total 16 (delta 0), reused 16 (delta 0)
Receiving objects: 100% (16/16), 47.23 KiB | 681.00 KiB/s, done.
warning: remote HEAD refers to nonexistent ref, unable to checkout.

Project [qwiklabs-gcp-02-4327c4e03d82] repository [sample-app] was cloned to [/home/student_03_49720296e995/sample-app].
Branch 'main' set up to track remote branch 'main' from 'origin'.
Switched to a new branch 'main'

सैंपल ऐप्लिकेशन बनाना

cd ${HOME}/sample-app
./mvnw compile

आउटपुट

[INFO] Scanning for projects...
...
[INFO] Compiling 1 source file to /home/student_03_49720296e995/sample-app/target/classes
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  10.080 s
[INFO] Finished at: 2022-02-23T17:14:30Z
[INFO] ------------------------------------------------------------------------

सैंपल ऐप्लिकेशन चलाना

cd ${HOME}/sample-app
./mvnw exec:java

आउटपुट

[INFO] Scanning for projects...
...
Listening at http://localhost:8080

चल रहे ऐप्लिकेशन की झलक देखना

  • Cloud Shell की वेब झलक देखने वाले बटन पर क्लिक करें
  • पोर्ट 8080 पर झलक देखें पर क्लिक करें

काम पूरा होने पर,

  • चल रहे ऐप्लिकेशन को रोकने के लिए, Cloud Shell में CTRL + c दबाएं

3. Dockerfile

Dockerfile की मदद से ऐप्लिकेशन को कंटेनर में बदलना

किसी ऐप्लिकेशन को कंटेनर में पैकेज करने का एक तरीका, Dockerfile का इस्तेमाल करना है. Dockerfile, स्क्रिप्ट की तरह होता है. यह डेमॉन को बताता है कि कंटेनर इमेज को कैसे असेंबल करना है. ज़्यादा जानकारी के लिए, Dockerfile का रेफ़रंस दस्तावेज़ देखें.

सैंपल ऐप्लिकेशन की रिपॉज़िटरी में, खाली Dockerfile बनाएं.

touch ${HOME}/sample-app/Dockerfile

अपनी पसंद के एडिटर में Dockerfile खोलें.

vi ${HOME}/sample-app/Dockerfile

शुरुआत करने के लिए कोई इमेज चुनें

कंटेनर बनाने के लिए Dockerfile का इस्तेमाल करने पर, कंटेनर को असेंबल करने के लिए ऐप्लिकेशन के बारे में सीधे तौर पर जानकारी होना ज़रूरी है. Dockerfile बनाने का पहला चरण, ऐसी इमेज चुनना है जिसका इस्तेमाल आपकी इमेज के आधार के तौर पर किया जाएगा. यह इमेज, पैरंट या बेस इमेज होनी चाहिए. इसे किसी भरोसेमंद सोर्स, जैसे कि आपकी कंपनी ने मेंटेन और पब्लिश किया हो.

FROM निर्देश, नई बिल्ड स्टेज शुरू करता है. साथ ही, क्रम से दिए गए बाद के निर्देशों के लिए, बेस इमेज सेट करता है. इसलिए, FROM निर्देश आम तौर पर Dockerfile में पहला निर्देश होता है. इसमें वैरिएबल इस्तेमाल करने के लिए, इससे पहले सिर्फ़ ARG निर्देश का इस्तेमाल किया जा सकता है.

सिंटैक्स: FROM <image>[:<tag> | @<digest>] [AS <name>]

इमेज का फ़ॉर्मैट <image>:<tag> या <image>@<digest> होना चाहिए. अगर कोई टैग या डाइजेस्ट नहीं दिया गया है, तो डिफ़ॉल्ट रूप से :latest टैग का इस्तेमाल किया जाता है. <image> का फ़ॉर्मैट, इमेज को सेव करने के लिए इस्तेमाल की गई रजिस्ट्री के हिसाब से अलग-अलग होता है. Artifact Registry के लिए, <image> फ़ॉर्मैट <region>-docker.pkg.dev/<project ID>/<repository name>/<image name>:<image tag> है.

इस लैब के लिए, हम सार्वजनिक openjdk:11.0-jdk इमेज का इस्तेमाल करते हैं. अपनी Dockerfile में यह लाइन जोड़ें

FROM openjdk:11.0-jdk

वर्किंग डायरेक्ट्री सेट करना

WORKDIR निर्देश, Dockerfile में इसके बाद दिए गए किसी भी क्रमवार निर्देश के लिए वर्किंग डायरेक्ट्री सेट करता है. ज़्यादा जानकारी के लिए, Dockerfile के रेफ़रंस दस्तावेज़ का WORKDIR सेक्शन देखें

सिंटैक्स: WORKDIR <path>

इस लैब के लिए, हम /app डायरेक्ट्री का इस्तेमाल WORKDIR के तौर पर करते हैं. अपनी Dockerfile के सबसे नीचे यह लाइन जोड़ें

WORKDIR /app

ऐप्लिकेशन की फ़ाइलें कॉपी करें

COPY निर्देश, डायरेक्ट्री या फ़ाइलों को <source> लोकेशन से इमेज फ़ाइल सिस्टम के <destination> पाथ पर कॉपी करता है. एक से ज़्यादा <source> रिसॉर्स तय किए जा सकते हैं. ये सभी, बिल्ड कॉन्टेक्स्ट से जुड़े होते हैं. बिल्ड कॉन्टेक्स्ट के बारे में, बिल्ड सेक्शन में ज़्यादा जानकारी दी जाएगी. ज़्यादा जानकारी के लिए, Dockerfile के रेफ़रंस दस्तावेज़ का COPY सेक्शन देखें

सिंटैक्स: COPY <source>... <destination>

इस लैब के लिए, हम रिपॉज़िटरी में मौजूद सभी फ़ाइलों को इमेज फ़ाइल सिस्टम में कॉपी करेंगे. इसके बाद, अपने Dockerfile के सबसे नीचे यह लाइन जोड़ेंगे

COPY . /app

ऐप्लिकेशन को कंपाइल करना

RUN निर्देश, मौजूदा इमेज के ऊपर नई इमेज लेयर में कमांड को लागू करता है और नतीजों को सेव करता है. कमिट की गई इमेज का इस्तेमाल, Dockerfile में क्रम से दिए गए चरणों के लिए किया जाएगा. ज़्यादा जानकारी के लिए, Dockerfile के रेफ़रंस दस्तावेज़ का RUN सेक्शन देखें

सिंटैक्स: RUN <command>

इस लैब के लिए, हम ऐप्लिकेशन को JAR फ़ाइल में कंपाइल करने के लिए Maven का इस्तेमाल करेंगे. अपनी Dockerfile के सबसे नीचे यह लाइन जोड़ें

RUN ./mvnw compile assembly:single

आवेदन शुरू करना

CMD निर्देश, चालू कंटेनर के लिए डिफ़ॉल्ट कमांड देता है. Dockerfile में सिर्फ़ एक CMD निर्देश हो सकता है. अगर एक से ज़्यादा CMD निर्देश दिए गए हैं, तो सिर्फ़ आखिरी CMD निर्देश लागू होगा. CMD और ENTRYPOINT, दोनों निर्देशों का इस्तेमाल करके ज़्यादा बेहतर तरीके से काम किया जा सकता है. हालांकि, इस लैब में इसके बारे में नहीं बताया गया है. ज़्यादा जानकारी के लिए, Dockerfile के रेफ़रंस दस्तावेज़ का CMD` सेक्शन देखें

सिंटैक्स: CMD ["executable","param1","param2"]

इस लैब के लिए, हम कंपाइल की गई JAR फ़ाइल को चलाते हैं. अपनी Dockerfile के सबसे नीचे यह लाइन जोड़ें

CMD ["java","-jar","/app/target/sample-app-1.0.0-jar-with-dependencies.jar"]

फ़ाइनल Dockerfile

आखिरी Dockerfile यह होगा

FROM openjdk:11.0-jdk
WORKDIR /app
COPY . /app
RUN ./mvnw compile assembly:single
CMD ["java","-jar","/app/target/sample-app-1.0.0-jar-with-dependencies.jar"]

Dockerfile को लोकल तौर पर कमिट करना

cd ${HOME}/sample-app
git add Dockerfile
git commit -m "Added Dockerfile"

4. बनाएं

अब हम docker build कमांड का इस्तेमाल करके, Dockerfile से इमेज बनाएंगे. इस कमांड से, Docker डेमॉन को हमारी Dockerfile में दिए गए निर्देशों का इस्तेमाल करके इमेज बनाने का निर्देश मिलता है. ज़्यादा जानकारी के लिए, docker build का रेफ़रंस दस्तावेज़ देखें.

इमेज बनाना

cd ${HOME}/sample-app
export IMAGE_TAG=$(git rev-parse --short HEAD)
docker build --tag sample-app:${IMAGE_TAG} .

आउटपुट

Sending build context to Docker daemon  221.2kB
Step 1/4 : FROM openjdk:11.0-jdk
11.0-jdk: Pulling from library/openjdk
0c6b8ff8c37e: Pull complete
412caad352a3: Pull complete
e6d3e61f7a50: Pull complete
461bb1d8c517: Pull complete
e442ee9d8dd9: Pull complete
542c9fe4a7ba: Pull complete
41de18d1833d: Pull complete
Digest: sha256:d72b1b9e94e07278649d91c635e34737ae8f181c191b771bde6816f9bb4bd08a
Status: Downloaded newer image for openjdk:11.0-jdk
---> 2924126f1829
Step 2/4 : WORKDIR /app
---> Running in ea037abb273d
Removing intermediate container ea037abb273d
---> bd9b6d078082
Step 3/4 : COPY . /app
---> b9aec2b5de51
Step 4/4 : RUN ./mvnw compile jar:jar
---> Running in 3f5ff737b7fd
[INFO] Scanning for projects...
...
[INFO] Building jar: /app/target/sample-app-1.0.0.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  22.952 s
[INFO] Finished at: 2022-02-23T18:09:08Z
[INFO] ------------------------------------------------------------------------
Removing intermediate container 331443caebd3
---> 152f65cc441e
Step 5/5 : CMD ["java", "-jar", "/app/target/sample-app-1.0.0.jar"]
---> Running in 3d595a72231c
Removing intermediate container 3d595a72231c
---> 0e40d7548cab
Successfully built 0e40d7548cab
Successfully tagged sample-app:aaa8895

5. चलाएं

कंटेनर इमेज को सफलतापूर्वक बनाने के बाद, अब हम अपने ऐप्लिकेशन को चला सकते हैं. साथ ही, यह पक्का कर सकते हैं कि यह docker run कमांड का इस्तेमाल करके, उम्मीद के मुताबिक काम कर रहा है. इस कमांड से, हमारा कंटेनर कमांड प्रॉम्प्ट के फ़ोरग्राउंड में लॉन्च हो जाएगा. इससे टेस्टिंग या डीबग करने में मदद मिलेगी. ज़्यादा जानकारी के लिए, docker run का रेफ़रंस दस्तावेज़ देखें.

इमेज का इस्तेमाल करके कंटेनर चलाना

cd ${HOME}/sample-app
export IMAGE_TAG=$(git rev-parse --short HEAD)
docker run \
  --rm \
  -p 8080:8080 \
  sample-app:${IMAGE_TAG}

आउटपुट

Listening at http://localhost:8080

कंटेनर में चल रहे ऐप्लिकेशन की झलक देखना

  • Cloud Shell की वेब झलक देखने वाले बटन पर क्लिक करें
  • पोर्ट 8080 पर झलक देखें पर क्लिक करें
  • कंटेनर बंद करने के लिए, Cloud Shell में CTRL + c दबाएं

कंटेनर के व्यवहार में बदलाव करना

Docker Run को एक्ज़ीक्यूट करने के लिए, Dockerfile में मौजूद डिफ़ॉल्ट कॉन्फ़िगरेशन का इस्तेमाल किया जाता है. इस व्यवहार में बदलाव करने के लिए, अतिरिक्त निर्देश और पैरामीटर जोड़े जा सकते हैं.

TRACE लॉगिंग चालू करना

cd ${HOME}/sample-app
export IMAGE_TAG=$(git rev-parse --short HEAD)
docker run \
  --rm \
  -p 8080:8080 \
  sample-app:${IMAGE_TAG} \
  java -Dorg.slf4j.simpleLogger.defaultLogLevel=trace -jar /app/target/sample-app-1.0.0-jar-with-dependencies.jar

कंटेनर में चल रहे ऐप्लिकेशन की झलक देखना

  • Cloud Shell की वेब झलक देखने वाले बटन पर क्लिक करें
  • पोर्ट 8080 पर झलक देखें पर क्लिक करें
  • Cloud Shell टैब पर स्विच करें और देखें कि अतिरिक्त लॉगिंग
  • कंटेनर को रोकने के लिए, Cloud Shell में CTRL + c दबाएं

पोर्ट बदलना

cd ${HOME}/sample-app
export IMAGE_TAG=$(git rev-parse --short HEAD)
docker run \
--rm \
-e PORT=8081 \
-p 8081:8081 \
sample-app:${IMAGE_TAG}

कंटेनर में चल रहे ऐप्लिकेशन की झलक देखना

  • Cloud Shell की वेब झलक देखने वाले बटन पर क्लिक करें
  • पोर्ट बदलें पर क्लिक करें
  • 8081 डालें
  • 'बदलें और झलक देखें' पर क्लिक करें
  • कंटेनर को रोकने के लिए, Cloud Shell में CTRL + c दबाएं

6. पुश

जब हमें यह पक्का हो जाए कि कंटेनर इमेज ठीक से काम कर रही है और हमें इस कंटेनर को अन्य एनवायरमेंट में और/या अन्य उपयोगकर्ताओं के लिए उपलब्ध कराना है, तो हमें इमेज को शेयर की गई रिपॉज़िटरी में पुश करना होगा. यह अपने-आप होने वाली बिल्ड पाइपलाइन का हिस्सा होना चाहिए. हालांकि, हमारे टेस्ट एनवायरमेंट में पहले से ही एक रिपॉज़िटरी कॉन्फ़िगर की गई है. इसलिए, हम अपनी इमेज को मैन्युअल तरीके से पुश कर सकते हैं.

Docker फ़ाइल के कमिट को sample-app रिपॉज़िटरी में पुश करें

cd ${HOME}/sample-app
export IMAGE_TAG=$(git rev-parse --short HEAD)
git push

Artifact Registry के लिए इमेज को टैग करना

docker tag sample-app:${IMAGE_TAG} \
    us-central1-docker.pkg.dev/${GOOGLE_CLOUD_PROJECT}/apps/sample-app:${IMAGE_TAG}

Artifact Registry के लिए क्रेडेंशियल कॉन्फ़िगर करना

gcloud auth configure-docker us-central1-docker.pkg.dev

जब कहा जाए, तब Do you want to continue (Y/n)? जवाब दें y और Enter दबाएं

इमेज को Artifact Registry में पुश करें

docker push us-central1-docker.pkg.dev/${GOOGLE_CLOUD_PROJECT}/apps/sample-app:${IMAGE_TAG}

आउटपुट

 The push refers to repository [us-central1-docker.pkg.dev/qwiklabs-gcp-04-b47ced695a3c/apps/sample-app]
  453b97f86449: Pushed
  e86791aa0382: Pushed
  d404c7ee0850: Pushed
  fe4f44af763d: Pushed
  7c072cee6a29: Pushed
  1e5fdc3d671c: Pushed
  613ab28cf833: Pushed
  bed676ceab7a: Pushed
  6398d5cccd2c: Pushed
  0b0f2f2f5279: Pushed
  aaa8895: digest: sha256:459de00f86f159cc63f98687f7c9563fd65a2eb9bcc71c23dda3351baf13607a size: 2424

7. बधाई हो!

बधाई हो, आपने कोडलैब पूरा कर लिया है!

आपने क्या-क्या कवर किया है

  • सैंपल ऐप्लिकेशन के लिए Dockerfile बनाया गया
  • इमेज बनाई गई
  • इमेज को स्थानीय तौर पर कंटेनर के तौर पर चलाया गया
  • कंटेनर के व्यवहार में बदलाव किया गया
  • इमेज को Artifact Registry में पुश किया गया