Docker — Hello world

ავტორები: Aleksi Kistauri, Nikoloz Bokeria

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

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

დოკერი არის კონტეინერიზაციის პლატფორმა (Runtime environmet), რომელიც გაძლევს საშუალებას, აპლიკაციისთვის შექმნა იზოლირებული გარემო, სადაც აპლიკაციასთან ერთად თავს მოუყრი მის მოდულებს(dependencies), კონფიგურაციის ფაილებს და ა.შ. რომლებიც საჭიროა აღნიშნული აპლიკაციის გასაშვებად.

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

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

რა არის კონტეინერი?

როგორც უკვე ავღნიშნეთ, კონტეინერი არის იზოლირებული გარემო, რომლისთვისაც კომპიუტერი გამოყოფს შესაბამის რესურსებს (Network, hardware …)

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

დოკერი არ არის ვირტუალური მანქანა !

ვირტუალური მანქანისგან განსხვავებით, კონტეინერი, არ საჭიროებს მისთვის გამოყოფილ ოპერაციულ სისტემას. ის იყენებს კერნელის ფუნქციონალს და გააჩნია საკუთარი namespace (გამოყოფილი რესური) რაც ნიშნავს იმას, რომ Network, Memory და ა.შ.გამოყოფს პატარა ნაწილს კონტეინერისთვის.

დოკერის ინსტალაცია

თუ შენ იყენებ OS X-ს ან Windows-ს დოკერი ავტომატურად დააინსტალირებს Linux-ის ვირტუალურ მანქანას.

OS X -ზე დასაყენებლად გვაქვს ორი ვარიანტი:

1. Homebrew — ის გამოყენებით, რომელიც ცოტა კომპლექსური პროცედურაა, რადგან ხელით გვიწევს ვირტუალური მანქანის დაყენება და კონფიგურაცია. installation docker with homebrew
2. შეგიძლია ჩამოტვირთო DMG- ფაილი და დააყენო როგორც აპლიკაცია — https://docs.docker.com/docker-for-mac/install/

Linux (Debian)

sudo apt update
sudo apt install apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable"
sudo apt update
apt-cache policy docker-ce
sudo apt install docker-ce

Windows

Windows-ის შემთხვევაში დოკერის ინსტალაცია შესაძლებელია მხოლოდ შემდეგ ვერსიებზე: Windows 10 64-bit: Pro, Enterprise, ან Education (Build 15063).

.EXE ფაილის ჩამოტვირთვა შესაძლებელია ლინკიდან — https://hub.docker.com/?overlay=onboarding

შევამოწმოთ დაყენდა თუ არა დოკერი:

# გახსენი CMD ან Terminal-ი და გაუშვი:
docker -v

Get hands dirty !

გავუშვათ პირველი Docker image

docker run hello-world

როდესაც გაუშვებ ამ Command-ს, დოკერი თავდაპირველად შეამოწმებს არის თუ არა აღნიშნული image ლოკალურად.

ჩვენ შემთხვევაში, hello-world ის image არ გვაქვს, ამიტომ ვიღებთ შეტყობინებას :

Unable to find image ‘hello-world:latest’ locally

დოკერი ავტომატურად ჩამოტვირთავს hub.docker.com — იდან ჩვენს image-ს.

Docker Hub — არის Docker-ის სერვისი, სადაც განთავსებულია სხვა და სხვა კონტეინერების image-ები (image- ზე მოგვიანებით ვილაპარაკოთ)

Docker Hub — ზე შეგვიძლია ავტვირთოთ საკუთარი Image-ები ან გამოვიყენოთ უკვე ატვირთული Image-ები როგორიცაა: Ngnix, Node, Redis და ა.შ.

როდესაც Image ჩამოიტვირთება გაეშვება კონტეინერი, რომელიც გამოიტანს ეკრანზე შემდეგ შეტყობინებას:

პრაქტიკული მაგალითი

Image ებისა და კონტეინერების უკეთესად გასაგებად, განვიხილოთ პრაქტიკული მაგილითი.

შევქმნათ Node-ის აპლიკაცია, რომელიც უბრალოდ დაგვიბრუნებს Hello from container! — ს.

https://github.com/nikolozz/docker_simple_app

იმისათვის, რომ აპლიკაცია გავუშვათ საჭიროა კონტეინერის Image.

Image-ის შესაქმნელათ ვწერთ Dockerfile-ს(root ფოლდერში) სადაც უნდა ავღწეროთ პროცესი, თუ როგორ უნდა შეიქმნას ჩვენი აპლიკაცია.

Dockerfile — ს არ ჭირდება არანაირი გაფართოება (.txt, .js, .sh …)

FROM node:alpine

FROM — ის მეშვეობით განვსაზღვრავთ base image-ს, რადგან ჩვენი აპლიკაცია არის Node-ზე base image-ად ვიყენებთ node:alpine -ს.

რადგან აქ უკვე დაყენებულია npm და Node.js, მაგალითად თუ base image-ად განვსაზღვრავდით Ubuntu-ს, ხელით მოგვიწევდა Node-ისა და npm ის დაყენება.

ასევე, Ubuntu -ს base image 1GB-ზე მეტია, ხოლო node:alpine 80 MB

WORKDIR /app

თუ შევალთ კონტეინერში და ვნახავთ ფაილებს, შევამჩნევთ ლინუქსის ფაილურ სტრუქტურას, რადგან base image ად node:alpine- გვაქვს გამოყენებული.

ფაილური სტრუქტურა დამოკიდებულია base image-ზე

აღნიშნული Command შექმნის ფოლდერს სახელად app, სადაც იქნება ჩვენი აპლიკაციის ფაილები.

COPY ./package.json ./
RUN npm i
COPY . .

COPY გვაძლევს საშუალებას გადავიტანოთ ლოკალური ფაილები კონტეინერში. ამ შემთხვევაში გადაგვაქვს package.json, სადაც გვაქვს Dependency ები, რომლებსაც შემდეგ ვაყენებთ npm i — ით (npm install)

RUN ის გამოყენებით შეგვიძლია გავუშვათ ნებისმიერი Command, მაგალითად npm

npm — უნდა იყოს base image ში.

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

იმისათვის, რომ node_modules არ დაკოპირდეს კონტეინერში, ვქმნით .dockerignore-ს და ვწერთ node_modules/ -ს

CMD [ "npm", "start" ]

CMD -ის გამოყენებით განვსაზღვრავთ Command-ს, რომელიც გაეშვება კონტეინერის დასტარტვის დროს.

ჩვენ დავწერეთ Dockerfile, რის მიხედვითაც შევქმნით image-ს და გავუშვებთ ჩვენ აპლიკაციას.

იმისათვის რომ დავბილდოთ Image, გადავდივართ იმ დირექტორიაში სადაც Dockerfile არის განთავსებული და ვუშვებთ შემდეგ Command-ს

docker build -t myapp .

docker build- ს პარამეტრად შეგვიძლია გადავცეთ -t (tag), რაც იქნება ჩვენი Image-ის სახელი, თუ არ გადავცემთ tag name -ს დოკერი ავტომატურად მიანიჭებს რენდომ tag name-ს.

ასევე, ბოლოში აუცილებლად ვწერთ წერტილს(.)-ს რაც განსაზღვრავს კონტექსტს..

თუ გავუშვებთ Command-ს

docker images

ვნახავთ რომ შეიქმნა ორი ახალი image — myapp და node(რადგან უკვე დაყენებული მქონდა, ქეშიდან აიღო)

იმისათვის, რომ კონტეინერი გავუშვათ ვიყენებთ Command-ს:

docker run myapp #(სადაც myapp თქვენი image-ს სახელია).

გაშვებული კონტეინერების სანახავად ვუშვებთ Command-ს:

docker ps

თუ ჩვენ შევეცდებით localhost:8000-ზე შესვლას გვიჩვენებს Network error-ს რადგან როგორც უკვე ვახსენეთ, კონტეინერი არის იზოლირებულ გარემოში.

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

რისთვისაც docker run ს უნდა გადავცეთ დამატებით პარამეტრი -p 8000:8000

რაც ნიშნავს იმას, რომ 8000 პორტიდან ვუკავშირდებით კონტეინერის 8000 პორტს.

docker run -p 8000:8000 myapp

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

და მაინც, რატომ დოკერი? 🤔

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

დღესდღეობით ძალიან ბევრი სერვისი (AWS ECS, AWS EKS, AWS Elastic beanstallk, GKE და ა.შ.)არსებობს, რომლებშიც შეგვიძლია ავტვირთოთ, ჩვენი კონტეინერები და მარტივად მოვაგვაროთ ისეთი პრობლემა როგორიცაა სქეილინგი.

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