Acest capitol acoperă comenzi noi din Docker și detalii despre cum să partajezi date între sistemul gazdă și aplicațiile containerizate. Vei învăța când și cum să folosești volume persistente și să accesezi sistemele de fișiere ale gazdei.

Comenzi Docker intermediare

Ajutor rapid

Containere existente

Curățarea automată a containerelor

Montarea sistemului de fișiere al gazdei

Transmiterea unui fișier către un container în execuție

Dispărut, dar nu uitat

Metode diferite, același rezultat

Volume persistente

Crearea unui volum de container

Containere diferite, același volum

Comenzi și sisteme de fișiere

Învață să expui servicii de rețea în Docker, să creezi rețele Docker și să folosești fișiere Dockerfile pentru a gestiona setările de rețea.

Recapitulare despre rețele

Care este adresa mea IP?

Porturi valide

Cum să faci serviciile de rețea disponibile în Docker

Maparea unui port

Mai multe containere, același port pe gazdă?

Expunerea porturilor cu Dockerfiles

Atât de multe opțiuni

Maparea unui port de container

Folosirea porturilor efemere

Rețele Docker

Crearea unei rețele Docker

Adăugarea containerelor într-o rețea

Intervale IP

Eliminarea rețelelor de containere

Rețele

Învață să folosești instrumentele avansate de gestionare și construire a imaginilor Docker pentru a crea imagini de containere compacte și eficiente. Creează imagini multi-platformă capabile să ruleze pe arhitecturi de procesoare diferite.

Optimizarea imaginilor Docker

Identifică preocupările

Explorarea imaginilor Docker

Alegerea celei mai potrivite imagini

Înțelegerea straturilor

Tortul cu straturi

Câte straturi?

Build-uri multi-etapă

Build cu o singură etapă

Build multi-stadiu

Înțelegerea build-urilor multi-stage

Build-uri multi-platformă

Pașii unui build multi-platformă

Build multi-platformă

Construirea imaginilor avansate de containere

Combină capabilitățile Docker de volume, rețele și gestionare a containerelor în aplicații multi-container folosind Docker Compose. Actualizează și gestionează implementările de aplicații prin intermediul fișierului docker-compose.yml.

Introducere în Docker Compose

Gestionarea unei aplicații cu Docker Compose

Depanarea pornirii aplicației

Crearea fișierelor compose.yaml

Scrierea unui fișier compose.yaml

Identificarea secțiunilor

Câte resurse?

Dependențe și depanare în Docker Compose

Ordinea de pornire a resurselor

Calculul dependențelor

Ordinea de oprire

FROM python:3.12-alpine3.19
WORKDIR /code
RUN apk add --no-cache gcc musl-dev linux-headers
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
COPY . .
CMD ["python3", "app.py"]


import time
import redis

cache = redis.Redis(host='redis', port=6379, socket_timeout=1)

def get_hit_count():
  retries = 5
  while True:
    try:
      return cache.incr('hits')
    except redis.exceptions.ConnectionError as exc:
      if retries == 0:
        raise exc
      retries -= 1
      time.sleep(0.5)

def hello():
  count = get_hit_count()
  return f'Successfully communicated {count} times.\n'

for i in range(0, 5):
  print(f"{hello()}")


services:
  app:
    build: .
  redis:
    image: "redis:alpine3.20"
    depends_on:
      - app


services:
  app:
    build: .
    depends_on:
      - redis
  redis:
    image: "redis:alpine3.20"


# Solution Steps:
  # 1. Run `docker compose up -d` to start the services
  # 2. Use `docker compose logs` to view the startup logs and identify errors
  # 3. Examine the compose.yaml file to find the dependency issue
  # 4. Update the compose.yaml to move depends_on from redis to app service
  # 5. Run `docker compose down` to stop all services
  # 6. Rerun `docker compose up -d` and verify you see "Successfully communicated" messages

Depanarea dependențelor

Crearea unui serviciu de date în Docker

import duckdb
from flask import Flask

app = Flask(__name__)

@app.route("/tripcount")
def returndata():
  cursor = duckdb.connect()
  try:
    count = cursor.execute("select count(*) from read_parquet('/data/*.parquet')").fetchall()[0][0]
    return f"Total trips: {count}"
  except duckdb.duckdb.IOException:
    return f"Data files are not present", 503

@app.route("/first")
def returnfirst():
  cursor = duckdb.connect()
  try:
    first = cursor.execute("select min(tpep_pickup_datetime) from read_parquet('/data/*.parquet')").fetchall()[0][0]
    return f"First pickup: {first:%Y/%m/%d}" 
  except duckdb.duckdb.IOException:
    return f"Data files are not present", 503

@app.route("/last")
def returnlast():
  cursor = duckdb.connect()
  try:
    last = cursor.execute("select max(tpep_pickup_datetime) from read_parquet('/data/*.parquet')").fetchall()[0][0]
    return f"Last pickup: {last:%Y/%m/%d}" 
  except duckdb.duckdb.IOException:
    return f"Data files are not present", 503


FROM python:3.12-alpine3.19

#
# NOTE: Application reads contents of /data in container
# If not found, application returns errors.
# 

WORKDIR /app
ENV FLASK_RUN_HOST=0.0.0.0

COPY code/app.py .
COPY code/requirements.txt .

RUN pip install -r requirements.txt --root-user-action=ignore

EXPOSE 5000

CMD ["flask", "run"]


STATUS_CODE=$(curl --silent --head http://localhost:5000/tripcount | awk '/^HTTP/{print $2}')

if [ "$STATUS_CODE" == "503" ]; then
  echo "ERROR ACCESSING DATA SERVICE - PLEASE VERIFY DATA IS PRESENT"
  echo "Did you use a -v flag with your docker run command?"
elif [ "$STATUS_CODE" == "200" ]; then
  echo "SUCCESSFULLY ACCESSED DATA SERVICE!"
else
  echo "ERROR ACCESSING DATA SERVICE - PLEASE VERIFY SERVICE IS RUNNING"
  echo "Did you start your container with a -p flag?"
fi
  


There are several steps required to complete this exercise:

- Build the dataservice container using the following command in the terminal:

docker build . -t dataservice

- Run an instance of the Docker container as follows:

docker run -d -p5000:5000 -v ~/workspace/datasets:/data dataservice

- Verify that the service is working by running the ./app_test.sh on the terminal


Crearea unui backend pentru serviciul de date

Adăugarea unui client de date

services:
  ____:
    image: dataservice
    volumes:
      - /home/repl/datasets:/data
    networks: 
      data_net:
        ipv4_address: 10.11.12.2

  dataclient:
    image: ____
    depends_on: 
      - ____
    networks:
      data_net:
        ipv4_address: 10.11.12.3

# Ignore everything below this line
networks:
  data_net:
    driver: macvlan
    ipam:
      config:
        - subnet: "10.11.12.0/24"
    


services:
  dataservice:
    image: dataservice
    volumes:
      - /home/repl/workspace/datasets:/data
    networks: 
      data_net:
        ipv4_address: 10.11.12.2

  dataclient:
    image: dataclient
    depends_on: 
      - dataservice
    networks:
      data_net:
        ipv4_address: 10.11.12.3

# Ignore everything below this line
networks:
  data_net:
    driver: macvlan
    ipam:
      config:
        - subnet: "10.11.12.0/24"
    


- Update the compose.yaml file as shown.
- Run the following command:

  docker compose up -d
  
- Run the command:

  docker compose logs dataclient


Folosirea Docker Compose pentru a defini o aplicație completă

Felicitări!

Docker Compose

Acest curs se bazează pe fundamentele învățate în cursul Introducere în Docker și extinde conceptele și instrumentele acoperite acolo, adăugând noțiuni despre gestionarea și optimizarea imaginilor de containere, rețele, comunicarea prin sistemul de fișiere, aplicații multi-platformă și multi-container. La final, vei putea să:

- Creezi build-uri multi-etapă pentru a optimiza dimensiunea, securitatea și reutilizabilitatea aplicațiilor containerizate.
- Folosești instrumentele și conceptele de rețea din Docker pentru a permite comunicarea între containere și pentru a expune servicii de rețea în rețeaua locală și în exterior.
- Partajezi fișiere și date între containere și mașina gazdă folosind montări și volume din sistemul de fișiere Docker.
- Creezi implementări de aplicații multi-container cu Docker Compose, simplificând considerabil configurarea unor instrumente complexe, frecvent utilizate în mediile de știința datelor și inginerie.

Vei obține cel mai mult din acest curs dacă ai deja experiență cu construirea unor containere simple și dorești să îți extinzi setul de instrumente pentru dezvoltare, testare și distribuție. Abia așteptăm să te ghidăm pe parcursul acestei experiențe de învățare a Docker.

Acest curs extinde cunoștințele dobândite în cursul Introducere în Docker, aprofundând conceptele și instrumentele de containerizare. Vom explora subiecte avansate precum gestionarea imaginilor de containere, rețelistică, comunicarea cu sistemul de fișiere și dezvoltarea de aplicații multi-platformă și multi-container.
<h2>Optimizarea aplicațiilor containerizate</h2>
Învață să creezi build-uri în mai multe etape pentru a îmbunătăți dimensiunea, securitatea și reutilizabilitatea aplicațiilor containerizate. Prin exerciții practice, stăpânești tehnicile de optimizare a imaginilor de containere, asigurând implementarea și gestionarea eficientă în medii diverse.
<h2>Îmbunătățirea implementărilor de containere cu Docker Compose</h2>
Descoperă cum să folosești instrumentele și conceptele de rețea Docker pentru a facilita comunicarea între containere și pentru a oferi servicii de rețea atât rețelelor locale, cât și celor externe. Explorați montările și volumele sistemului de fișiere pentru partajarea fără probleme a datelor între containere și mașina gazdă. În plus, dobândești competențe în Docker Compose pentru orchestrarea implementărilor de aplicații multi-container, simplificând configurarea instrumentelor complexe, frecvent întâlnite în mediile de data science și inginerie.
<h2>Împuternicirea dezvoltării și implementării</h2>
Acest curs vă oferă competențele esențiale pentru a vă îmbunătăți procesele de dezvoltare, testare și distribuție. Deși nu este esențial, vei obține cele mai bune rezultate din acest curs dacă ai lucrat cu și ai creat câteva containere simple. La finalul cursului, vei avea cunoștințele și instrumentele necesare pentru a optimiza aplicațiile containerizate, a eficientiza comunicarea dintre containere și a implementa cu ușurință aplicații multi-container, oferindu-ți încredere în parcursul tău de învățare Docker.

Introduction to Docker

Stăpânește construcțiile multi-etapă, uneltele de rețea Docker și Docker Compose pentru aplicații optime!

Docker intermediar

Stăpânește build-uri multi-etapă, instrumente de rețea Docker și Docker Compose pentru aplicații containerizate optime!

Identificarea secțiunilor

Docker intermediar

Exercițiu interactiv practic