# Docker-ის შესავალი სახელმძღვანელო: სწრაფად დაიწყეთ თქვენი აპლიკაციის კონტეინერიზაცია

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

## Docker-ის ძირითადი კონცეფციები

პრაქტიკის დაწყებამდე აუცილებელია Docker-ის რამდენიმე ძირითადი კონცეფციის გაგება:

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

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

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

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

*   **Docker Compose:** Docker Compose არის ინსტრუმენტი მრავალკონტეინერიანი Docker-ის აპლიკაციების განსაზღვრისა და გაშვებისთვის. ის საშუალებას გაძლევთ გამოიყენოთ YAML ფაილი აპლიკაციის სერვისების კონფიგურაციისთვის და შემდეგ გამოიყენოთ ერთი ბრძანება ყველა სერვისის დასაწყებად ან შესაჩერებლად.

## Docker-ის ინსტალაცია

პირველ რიგში, თქვენ უნდა დააინსტალიროთ Docker. Docker გთავაზობთ ინსტალაციის პაკეტებს სხვადასხვა ოპერაციული სისტემისთვის. ეწვიეთ [Docker-ის ოფიციალურ ვებსაიტს](https://www.docker.com/get-started/) და მიჰყევით შესაბამის ინსტრუქციებს ინსტალაციისთვის.

ინსტალაციის დასრულების შემდეგ, შეგიძლიათ შეამოწმოთ Docker-ის სწორად ინსტალაცია `docker --version` ბრძანების გაშვებით.

## მარტივი Python აპლიკაციის კონტეინერიზაცია

ჩვენ შევქმნით მარტივ Python აპლიკაციას და გამოვიყენებთ Docker-ს მის კონტეინერიზაციისთვის.

### 1. Python აპლიკაციის შექმნა

შექმენით ფაილი სახელად `app.py`, რომელიც შეიცავს შემდეგ კოდს:

```python
from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello, Docker!"

if __name__ == "__main__":
    app.run(debug=True, host='0.0.0.0')

ეს მარტივი Flask აპლიკაცია დააბრუნებს "Hello, Docker!" ძირეულ ბილიკზე /.

2. requirements.txt ფაილის შექმნა

აპლიკაცია დამოკიდებულია Flask ბიბლიოთეკაზე, ჩვენ უნდა შევქმნათ requirements.txt ფაილი ამ დამოკიდებულებების გამოსაცხადებლად.

Flask

3. Dockerfile-ის შექმნა

შექმენით ფაილი სახელად Dockerfile და დაამატეთ შემდეგი შინაარსი:

# გამოიყენეთ ოფიციალური Python გამოსახულება, როგორც ძირითადი გამოსახულება
FROM python:3.9-slim-buster

# დააყენეთ სამუშაო დირექტორია
WORKDIR /app

# დააკოპირეთ requirements.txt ფაილი სამუშაო დირექტორიაში
COPY requirements.txt .

# დააინსტალირეთ დამოკიდებულებები
RUN pip install --no-cache-dir -r requirements.txt

აპლიკაციის კოდის კოპირება სამუშაო დირექტორიაში

COPY app.py .

5000 პორტის გამოაშკარავება

EXPOSE 5000

გაშვების ბრძანების განსაზღვრა

CMD ["python", "app.py"]

**Dockerfile-ის განმარტება:**

*   `FROM python:3.9-slim-buster`: განსაზღვრავს საბაზისო იმიჯს, როგორც Python 3.9-ის გამარტივებულ ვერსიას.
*   `WORKDIR /app`: აყენებს კონტეინერის შიგნით სამუშაო დირექტორიას `/app`-ზე.
*   `COPY requirements.txt .`: მიმდინარე დირექტორიიდან `requirements.txt` ფაილის კოპირება კონტეინერის `/app` დირექტორიაში.
*   `RUN pip install --no-cache-dir -r requirements.txt`: კონტეინერის შიგნით `pip` ბრძანების გაშვება `requirements.txt` ფაილში მითითებული დამოკიდებულებების დასაყენებლად. `--no-cache-dir` პარამეტრი ამცირებს იმიჯის ზომას.
*   `COPY app.py .`: მიმდინარე დირექტორიიდან `app.py` ფაილის კოპირება კონტეინერის `/app` დირექტორიაში.
*   `EXPOSE 5000`: აცხადებს, რომ კონტეინერი მოუსმენს 5000 პორტს.
*   `CMD ["python", "app.py"]`: განსაზღვრავს კონტეინერის გაშვებისას შესასრულებელ ბრძანებას.

### 4. Docker-ის იმიჯის აწყობა

`Dockerfile`-ის შემცველ დირექტორიაში გაუშვით შემდეგი ბრძანება Docker-ის იმიჯის ასაწყობად:

```bash
docker build -t my-python-app .

• docker build: იმიჯის ასაწყობი ბრძანება.
• -t my-python-app: იმიჯისთვის სახელის მითითება (my-python-app).
• .: განსაზღვრავს Dockerfile-ის მდებარე დირექტორიას (მიმდინარე დირექტორია).

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

5. Docker-ის კონტეინერის გაშვება

გამოიყენეთ შემდეგი ბრძანება Docker-ის კონტეინერის გასაშვებად:

docker run -d -p 5000:5000 my-python-app

• docker run: კონტეინერის გაშვების ბრძანება.
• -d: კონტეინერის გაშვება გამოყოფილ რეჟიმში (ფონზე გაშვება).
• -p 5000:5000: ჰოსტის 5000 პორტის კონტეინერის 5000 პორტზე მიბმა.
• my-python-app: გამოსაყენებელი იმიჯის სახელის მითითება.

6. აპლიკაციის შემოწმება

ბრაუზერში ეწვიეთ http://localhost:5000-ს, სადაც უნდა ნახოთ "Hello, Docker!"

7. კონტეინერის შეჩერება და წაშლა

გამოიყენეთ შემდეგი ბრძანება კონტეინერის შესაჩერებლად:

docker stop 

`` შესაძლებელია docker ps ბრძანებით ნახვა.

გამოიყენეთ შემდეგი ბრძანება კონტეინერის წასაშლელად:

docker rm 

Docker Compose-ის შესავალი

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

1. docker-compose.yml ფაილის შექმნა

შექმენით ფაილი სახელად docker-compose.yml და დაამატეთ შემდეგი შიგთავსი:

version: "3.9"
services:
  web:
    image: my-python-app
    ports:
      - "5000:5000"

docker-compose.yml-ის განმარტება:* version: "3.9": განსაზღვრავს Docker Compose ფაილის ვერსიას.

• services: განსაზღვრავს აპლიკაციის სერვისებს.
• web: განსაზღვრავს სერვისს სახელად "web".
• image: my-python-app: განსაზღვრავს სერვისის მიერ გამოყენებულ იმიჯს.
• ports: განსაზღვრავს პორტების მიბმას.

2. აპლიკაციის გაშვება

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

docker-compose up -d

• docker-compose up: აპლიკაციის გაშვების ბრძანება.
• -d: კონტეინერის გაშვება გამოყოფილ რეჟიმში.

3. აპლიკაციის შეჩერება

გამოიყენეთ შემდეგი ბრძანება აპლიკაციის შესაჩერებლად:

docker-compose down

Docker-ის უსაფრთხოების საუკეთესო პრაქტიკა

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

• გამოიყენეთ ოფიციალური იმიჯები: შეძლებისდაგვარად გამოიყენეთ ოფიციალურად მოწოდებული იმიჯები, რომლებიც, როგორც წესი, გადიან უსაფრთხოების სკანირებას და ტექნიკურ მომსახურებას.
• დაასკანირეთ იმიჯის დაუცველობა: გამოიყენეთ ისეთი ხელსაწყოები, როგორიცაა Trivy, იმიჯში ცნობილი დაუცველობის სკანირებისთვის და დროულად განაახლეთ იმიჯი.
• გამოიყენეთ მინიმალური პრივილეგიების პრინციპი: მოერიდეთ კონტეინერების root მომხმარებლის სახელით გაშვებას.
• შეზღუდეთ კონტეინერის რესურსები: გამოიყენეთ cgroups კონტეინერის CPU-სა და მეხსიერების გამოყენების შესაზღუდად.
• რეგულარულად განაახლეთ იმიჯები: შეინახეთ იმიჯები განახლებული, რათა გამოსწორდეს უსაფრთხოების ხარვეზები.
• გამოიყენეთ უსაფრთხოების სკანირების ხელსაწყოები: ისეთი ხელსაწყოები, როგორიცაა Snyk, Clair და ა.შ., შეიძლება ინტეგრირებული იყოს თქვენს CI/CD პროცესში, რათა ავტომატურად დაასკანიროთ იმიჯის დაუცველობა.

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