Docker დამწყებთათვის: რა არის Docker და როგორ შევქმნათ Docker Containers

თუ ბოლო რამდენიმე წლის განმავლობაში დაუკავშირდით პროგრამირების უახლეს მოვლენებს, შეამჩნევდით ხმამაღალ ზუზუნს Docker და Docker კონტეინერების გარშემო. დოკერის ეს პოპულარობა არ არის უსაფუძვლო. დოკერის დანერგვამ მნიშვნელოვნად შეცვალა დეველოპერების მიდგომა განაცხადის შემუშავებაზე.

ვის სურს დარჩეს უკან, როდესაც ასეთი რევოლუციური ტექნოლოგია მოხვდება პროგრამირების სამყაროში? დღეს, ჩვენ ვიწყებთ ახალ სამეურვეო სერიას, რომ ისწავლოთ თუ როგორ გამოიყენოთ Docker აპლიკაციების შემუშავებისთვის. თუ თქვენ Docker- ის აბსოლუტური დამწყები ხართ, ეს სახელმძღვანელო სწორი ადგილია თქვენთვის.

ჩვენი სამეურვეო სერიის პირველ სტატიაში ჩვენ ვცდილობთ გავიგოთ რა არის Docker და რატომ უყვართ დეველოპერებს Docker ასე ძალიან. ჩვენ ასევე მოვაქცევთ მარტივი Node.js აპლიკაციას, რომ გაეცნოთ Docker– ის ძირითად კონცეფციებს.


რატომ აღარ უნდა დაველოდოთ? Მოდით დავიწყოთ!



რა არის დოკერი

დოკერი არის ინსტრუმენტი, რომელიც გამოიყენება პროგრამების შესაქმნელად; ეს არის პროგრამების შექმნა, განთავსება და გაშვება კონტეინერების საშუალებით.


კონტეინერით, ყველა ბიბლიოთეკა და სხვა დამოკიდებულებები, რომლებიც საჭიროა პროგრამის გასაშვებად, შეფუთულია, როგორც განლაგების ერთი პაკეტი.

აპლიკაციის კონტეინერების ძირითადი მიზანი არის მათი იზოლირება სხვა პროგრამაში, რომელიც მუშაობს იმავე სისტემაში. ეს მიდგომა უზრუნველყოფს პროგრამების ერთმანეთთან მუშაობაში ჩარევას და განაცხადის შენარჩუნებას ბევრად უფრო მარტივს.

მიუხედავად იმისა, რომ იმავე სისტემაში მომუშავე კონტეინერები იზოლირებულია ერთმანეთისგან შესრულებისას, ისინი იზიარებენ იგივე OS ბირთვს. ამრიგად, კონტეინერები უფრო მსუბუქია, ვირტუალური მანქანების იზოლირების ალტერნატიულ არჩევანთან შედარებით.

თქვენს Windows OS- ზე გაშვებული კონტეინერირებული პროგრამა გარანტირებულია, რომ გარემოს შეცვლის მიუხედავად, სხვა მომხმარებლის Windows აპარატში პრობლემის გარეშე გაუშვებს.


მიუხედავად იმისა, რომ კონტეინერები დიდი ხანია იყენებენ დოკერამდე, შემქმნელთა საზოგადოებაში Docker- ის პოპულარიზაცია მოხდა კონტეინერების გამოყენებით. არსებობს ორი კომპონენტი, რომლებიც გამოიყენება აპლიკაციის დოკერიზაციისას: დოკერფილი და დოკერ გამოსახულება . მოდით გავეცნოთ რა არის ისინი.

დოკერფილი

Dockerfile არის ტექსტური ფაილი, რომელიც შეიცავს ბრძანებების ერთობლიობას, რომლებიც საჭიროა docker სურათის შესაქმნელად. Dockerfile შეიცავს ინფორმაციას ძირითადი სისტემის, ენის, ფაილის ადგილმდებარეობისა და ქსელის პორტების შესახებ.

დოკერ გამოსახულება

როდესაც docker's build ბრძანებას აწარმოებთ dockerfile– ით, dockerfile– ს საფუძველზე იქმნება docker სურათი. ისინი შაბლონების როლს ასრულებენ საბოლოო დოკერის კონტეინერის შესაქმნელად. შექმნის შემდეგ, დოკერის სურათები სტატიკურია. Docker's run ბრძანების გამოყენება შეგიძლიათ docker კონტეინერის შესაქმნელად.



Node.js აპლიკაციის დოკერიზაცია

ამ სახელმძღვანელოში ჩვენ ვაპირებთ Node.js აპლიკაციის დოკერიზაციას. ჩვენ მივყვებით ეტაპობრივად მიდგომას, რომ დოკერის კონტეინერი ამუშავდეს.


1 - შექმენით Node.js პროგრამა 2 - შექმენით dockerfile 3 - ააშენეთ docker სურათი 4 - შექმენით პროგრამის კონტეინერი

სანამ ჩვენს აპს მოახსენებთ, დარწმუნდით, რომ თქვენს სისტემაში დაინსტალირებულია Docker და Node.js.

  • დააინსტალირეთ Docker თქვენს სისტემაში - ამ სახელმძღვანელოში მე არ განვაცხადებ, თუ როგორ უნდა დააყენოთ Docker, მაგრამ თქვენ შეგიძლიათ მიყვეთ Docker– ის დოკუმენტაციას და დააინსტალიროთ Docker თქვენს Windows ან Ubuntu– ის სამუშაო მაგიდაზე.
  • ჩამოტვირთეთ და დააინსტალირეთ Node.js ოფიციალური ვებ – გვერდიდან

შექმენით Node.js პროგრამა

ბრძანების სტრიქონიდან გადადით ახალ პროექტის დირექტორიაში და აწარმოეთ შემდეგი ბრძანება packet.json ფაილის შესაქმნელად, რომელიც შეიცავს ინფორმაციას პროგრამის დამოკიდებულების და სკრიპტის დაწყების შესახებ.

npm init -y


ამის შემდეგ, დააინსტალირეთ და დაამატეთ Express, როგორც თქვენი აპლიკაციის დამოკიდებულება, ამ ბრძანების შესრულებით ბრძანების ხაზზე. ჩვენ გამოვიყენებთ Express- ს, რომ შევქმნათ აპი.

npm install express --save

ეს დაამატებს გამოხატვას, როგორც დამოკიდებულება ჩვენს package.json ფაილი

ახლა ჩვენ შეგვიძლია შევქმნათ Node პროგრამა Express- ის დახმარებით.


შექმენით ფაილი სახელწოდებით app.js პროექტის დირექტორიაში და დაამატეთ შემდეგი კოდი ფაილში.

const express = require('express') const app = express() app.get('/', (req, res) => {
res.send('Hello World!') }) app.listen(3000, () => {
console.log('Node server has started running') })

ზემოთ მოცემული კოდი ქმნის Node სერვერს, რომელიც უსმენს შემომავალ მოთხოვნებს პორტის 3000 – ზე. შეგიძლიათ ამ ბრძანების შესრულება ბრძანების სტრიქონზე, Node სერვერის დასაწყებად.

node app.js

ახლა გადადით თქვენს ბრაუზერში და მიჰყევით URL- ს http://localhost:3000 და ნახავთ ტექსტს Hello World! გვერდზე.

ჩვენი პროექტისთვის ჩვენ შევქმენით მარტივი კვანძის პროგრამა. ახლა გადავიდეთ dockerfile- ის შექმნაზე.

შექმენით Dockerfile

Dockerfile- ში ჩვენ ვაწვდით ინფორმაციას, რაც საჭიროა ჩვენი Node აპის შესაქმნელად და გასაშვებად Docker გარემოში.

ეს მოიცავს აპლიკაციაში გამოყენებული ენისა და მისი ვერსიის დაზუსტებას, ჩვენი სამუშაო დირექტორიის სამუშაო დირექტორიად დაყენებას, სამუშაო დირექტორიაში ყველა ფაილის კოპირებას, ქსელის პორტის დაყენებას და რომელი ფაილის განაცხადს წარმოადგენს. უფრო რთულ აპლიკაციებში, თქვენ ასევე უნდა დადოთ გარემო ცვლადები და მონაცემთა ბაზის URL ასევე dockerfile- ში.

FROM node:latest WORKDIR /dockerTutorial COPY . . RUN npm install EXPOSE 3000 ENTRYPOINT ['node', 'app.js']
  • ფრომიდან ბრძანება იძენს OS გამოსახულებას, ჩვენი აპლიკაციის გასაშვებად კონკრეტულ OS– ზე, Docker Hub– დან. Docker Hub არის docker სურათების საცავი, რომელიც შეგვიძლია ადგილობრივი გარემოში მოვიზიდოთ. ჩვენ ვიღებთ Ubuntu- ზე დაფუძნებულ სურათს, რომელიც დაინსტალირებულია Node.js. კვანძის ვერსიისთვის 'უახლესი' -ს გამოყენება გამოსახავს სურათს, რომელზეც დაინსტალირებულია კვანძის უახლესი ვერსია.
  • სამუშაო ბრძანება ადგენს პროგრამის სამუშაო დირექტორიას.
  • კოპირება ბრძანება ასლებს ფაილებს მიმდინარე დირექტორიიდან (ბრძანების ხაზზე) სამუშაო დირექტორიაში, რომელიც მითითებულია წინა ეტაპზე. თქვენ შეგიძლიათ მიუთითოთ ფაილის სახელი კოპირებისთვის, ან გამოიყენოთ ორმაგი წერტილები, რომ მიმდინარე ფაილი შეიტანოს ყველა ფაილი სამუშაო დირექტორიაში.
  • გაუშვით ბრძანება აყენებს ყველა დამოკიდებულებას, რაც საჭიროა პროგრამის შესაქმნელად. ეს მოიცავს ყველა დამოკიდებულებას, რომლებიც მითითებულია package.json ფაილი
  • გამოაშკარავება ბრძანება ხსნის პორტს დოკერის კონტეინერიდან გარე სამყაროსთან. ეს პორტი იღებს ყველა მოთხოვნას, რომელსაც ჩვენ ვგზავნით დოკერის კონტეინერს. პორტი სპეციალურად არის მითითებული 3000-ზე, რადგან ეს არის პორტი, რომელსაც ჩვენი Node პროგრამა იყენებს Docker კონტეინერში, მოთხოვნების მოსასმენად.
  • ᲨᲔᲡᲕᲚᲘᲡ ᲬᲔᲠᲢᲘᲚᲘ განსაზღვრავს, თუ როგორ უნდა დაიწყოს პროგრამა. Docker უერთდება მასივს, რომელსაც ჩვენ ვუწვდით ერთ ბრძანებას, რომ დაიწყოს პროგრამა. ამ შემთხვევაში, node app.js.

Docker გამოსახულების შექმნა

გამოიყენეთ შემდეგი ბრძანება Dockerfile- დან Docker სურათის შესაქმნელად.

docker build -t docker-tutorial .

Docker-tutorial არის დოკერის გამოსახულების სახელი. წერტილი მიუთითებს ფაილის გზას პროექტის დირექტორიაში, სადაც ახლა ბრძანების სტრიქონში ვართ.

თუ ოპერაციული სისტემა მითითებულია ფრომიდან ბრძანება, კვანძი: უახლესი , ამჟამად არ არის თქვენს მოწყობილობაზე, ის გაიყვანება Docker Hub- დან, როდესაც თქვენ შეასრულებთ ზემოთ მითითებულ ბრძანებას.

სურათის გაყვანის შემდეგ dockerfile- ში თითოეული ბრძანება შესრულდება სათითაოდ.

აღსრულების ბოლოს, თუ შეტყობინებას ხედავთ წარმატებით აშენდა , აპლიკაციის docker სურათი წარმატებით აშენდა. გაუშვით ეს ბრძანება, რომ ნახოთ docker სურათის ნახვა ადგილობრივი სურათის საცავში.

docker images

გამომავალი ასე გამოიყურება

კონტეინერის შექმნა

ახლა ჩვენ შეგვიძლია გამოვიყენოთ გამოსახულება, რომ შევქმნათ Docker კონტეინერი. გამოიყენეთ docker run ბრძანება კონტეინერის შესაქმნელად.

docker run -p 8080:3000 docker-tutorial

აქ, ციფრები 8080 და 3000 მიუთითებს კონტეინერის გარე და შიდა ნაწილებზე. გარე პორტი, 8080, არის პორტი, რომელსაც ჩვენი ბრაუზერის საშუალებით ვუკავშირდებით პროგრამას. შიდა პორტი, 3000 არის ის პორტი, რომელსაც ჩვენი პროგრამა უსმენს შემომავალ მოთხოვნებს. დოკერის კონტეინერი ასახავს მოცემულ გარე პორტს შიდა პორტში.

ეწვიეთ URL http://localhost:8080 ბრაუზერზე და ნახეთ, გვერდი გაქვთ თუ არა Hello World! შეტყობინება, რომელიც მიიღეთ სტუმრობის დროს http://localhost:3000 მანამდე თუ კი, თქვენი Docker კონტეინერი მუშაობს და მუშაობს.

შეგიძლიათ გამოიყენოთ ეს ბრძანება, რომ ნახოთ თქვენი მოწყობილობის ყველა გაშვებული დოკერის კონტეინერი.

docker ps

ბრძანება მოგცემთ ამგვარ შედეგს. გაშვებული კონტეინერის CONTAINER_ID და NAME გვხვდება აქ.

თქვენს პროგრამას ემატება გარემოს ცვლადები

გახსოვთ, როგორ ვახსენე პროგრამა გარემოს ცვლადებით და უფრო მეტ ინსტრუქციას მოითხოვს dockerfile- ში? გარემოს ცვლადის მნიშვნელობა იცვლება იმ გარემოში, სადაც ისინი მუშაობენ.

გაითვალისწინეთ, თუ როგორ ავღნიშნეთ პორტი, რომელსაც ჩვენი Node აპლიკაცია უსმენს სერვერის გაშვების დროს. ეს მიდგომა მოუქნელია და მიდრეკილია შეცდომებისკენ. იმ შემთხვევაში, თუ ჩვენს აპლიკაციას ვატარებთ გარემოში, რომელიც არ ხსნის კვანძის სერვერის 3000 პორტს, ჩვენი პროგრამა წყვეტს მუშაობას.

ყველაზე შესაფერისი განხორციელება არის პორტის ნომრის ამოღება აპლიკაციიდან. ამის ნაცვლად, პორტის ნომრის ნაცვლად ვიყენებთ ცვლადის სახელს და ამ ცვლადის მნიშვნელობას ვაყენებთ გაშვებულ გარემოში. ჩვენს შემთხვევაში, გაშვებული გარემოა დოკერის კონტეინერი. ასე რომ, ჩვენ უნდა დავამატოთ პორტის ნომერი dockerfile– ს, როგორც გარემოს ცვლადი.

ვნახოთ, როგორ შეგვიძლია ამის გაკეთება.

პირველ რიგში, დაამატეთ ეკოლოგიური ცვლადი ჩვენს dockerfile– ს თავისი მნიშვნელობით. ამის მისაღწევად dockerfile- ს უნდა დავამატოთ ახალი ბრძანება.

FROM node:latest WORKDIR /dockerTutorial COPY . . ENV PORT=3000 RUN npm install EXPOSE $PORT ENTRYPOINT ['node', 'app.js']

ENV ბრძანების გამოყენებით, რასაც მოჰყვება ცვლადის სახელი და მნიშვნელობის მინიჭება, ჩვენს dockerfile- ს შეგვიძლია დავამატოთ ახალი გარემოსდაცვითი ცვლადი. შეამჩნიეთ როგორ შეიცვალა EXPOSE 3000 ბრძანება, რომ პირდაპირ არ აღინიშნოს პორტის ნომერი? ამის ნაცვლად, იგი ეხება შექმნილ PORT ცვლადს პორტის ზუსტი ნომრის მისაღებად. ამ მიდგომით, თუ პორტის ნომერი უნდა შევცვალოთ, მხოლოდ ერთი ადგილი უნდა შევცვალოთ ჩვენს კოდში, რაც ჩვენი აპლიკაციის შენარჩუნებას აადვილებს.

ახლა ჩვენ შევცვალეთ dockerfile, შემდეგი ნაბიჯი არის app.js შეცვლა შექმნილი გარემოს ცვლადის მითითებით. ამისათვის, ჩვენ ვცვლით პორტის ნომერს 3000, რომელიც გამოიყენება მოსმენის მეთოდში, process.env.PORT- ით.

const express = require('express') const app = express() app.get('/', (req, res) => {
res.send('Hello World!') }) app.listen(process.env.PORT, () => {
console.log('Node server has started running') })

მას შემდეგ, რაც ჩვენ შეიტანეთ ცვლილებები აპლიკაციის ფაილებში და dockerfile– ში, ახალი კონტეინერისთვის უნდა შევქმნათ ახალი სურათი. პირველ რიგში, ამის მისაღწევად უნდა შევაჩეროთ ამჟამად გაშვებული დოკერის კონტეინერი.

ჩვენ შეგვიძლია გამოვიყენოთ docker stop ბრძანება კონტეინერის შესაჩერებლად.

docker stop f10

მნიშვნელობა, f10, რომელიც გამოიყენება ამ ბრძანებაში არის კონტეინერის პირადობის პირველი სამი ციფრი.

ჩვენ შეგვიძლია გამოვიყენოთ ბრძანება, docker kill, რომ შევაჩეროთ გაშვებული კონტეინერი.

docker kill f10

Docker kill- სა და docker stop- ს შორის განსხვავება ისაა, რომ docker stop უფრო მოხდენილად აჩერებს კონტეინერს რესურსების გამოყენებით გათავისუფლებით და სახელმწიფოს დაზოგვით. docker kill, უფრო სწრაფად, აჩერებს კონტეინერს რესურსების სათანადო გამოთავისუფლების ან სახელმწიფოს გადარჩენის გარეშე. საწარმოო გარემოში გაშვებული კონტეინერისთვის კონტეინერის შესაჩერებლად დოკერის გაჩერების გამოყენება უკეთესი არჩევანია.

გაშვებული კონტეინერის შეჩერების შემდეგ, დარწმუნდით, რომ კონტეინერის დარჩენილი ნარჩენები გაასუფთავეთ მასპინძელი გარემოდან შემდეგი ბრძანების გამოყენებით.

კონტეინერის გაშვება Daemon რეჟიმში

როდესაც თქვენ ცდილობთ აწარმოოთ ზემოაღნიშნული ბრძანებები კონტეინერის შესაჩერებლად, შეამჩნევდით, რომ ტერმინალის ჩანართი, რომელსაც კონტეინერის შესაქმნელად ვიყენებდით, აღარ შეიძლება გამოყენებულ იქნას ბრძანებების გასაშვებად, თუ არ მოვიკლებთ კონტეინერს. ამის პოვნა შეგვიძლია გამოვიყენოთ ცალკე ჩანართის გამოყენებით ახალი ბრძანებების გასაშვებად.

მაგრამ უკეთესი მიდგომაა. ჩვენ შეგვიძლია გავატაროთ კონტეინერი daemon რეჟიმში. Daemon რეჟიმის საშუალებით, კონტეინერი მუშაობს ფონზე, თუ არ იყენებთ მიმდინარე ჩანართს შედეგების საჩვენებლად.

Daemon რეჟიმში კონტეინერის დასაწყებად, თქვენ უბრალოდ უნდა დაამატოთ დამატებითი -d დროშა docker run ბრძანებას.

docker run -d -p 8080:3000 docker-tutorial

კონტეინერის ინტერაქტიულ რეჟიმში გაშვება

კონტეინერის ინტერაქტიულ რეჟიმში გასაშვებად, კონტეინერი უკვე უნდა მუშაობდეს. ინტერაქტიულ რეჟიმში მოხვედრისას, შეგიძლიათ შეასრულოთ ბრძანებები, რომ დაამატოთ ან წაშალოთ ფაილები კონტეინერში, ჩამოთვალოთ ფაილები, ან გაუშვათ სხვა bash ბრძანებები, რომლებსაც ჩვეულებრივ ვიყენებთ.

გამოიყენეთ შემდეგი ბრძანება კონტეინერის ინტერაქტიულ რეჟიმში გასაშვებად.

docker exec -it e37 bash

აქ, e37 არის კონტეინერის ID. ითამაშეთ ინტერაქტიული რეჟიმით bash ბრძანებების გამოყენებით.



დასკვნა

ჩვენი დოკერის სამეურვეო სერიის პირველ სახელმძღვანელოში თქვენ ისწავლეთ როგორ უნდა შექმნათ დოკერის კონტეინერი მარტივი Node.js პროგრამისთვის. Docker- ით და კონტეინერებით კიდევ უფრო მეტი რამის გაკეთება შეგიძლიათ. ჩვენს მომავალ სახელმძღვანელოებში ვნახავთ, თუ როგორ უნდა ვიმუშაოთ მონაცემთა ბაზებთან, მოცულობებთან და მრავალ კონტეინერებთან მუშაობა, რომლებიც გამოიყენება მიკრო სერვისებით აშენებული პროგრამის მიერ.