Det här kapitlet behandlar nya Docker-kommandon och hur du delar data mellan värdsystemet och containeriserade applikationer. Du lär dig när och hur du använder beständiga volymer och kommer åt värdsystemets filsystem.

Docker-kommandon på mellannivå

Snabb hjälpöversikt

Befintliga containrar

Automatisk containerrensning

Montera värdsystemets filsystem

Skicka en fil till en körande container

Borta, men inte glömd

Olika metoder, samma resultat

Beständiga volymer

Skapa en containervolym

Olika containers, samma volym

Kommandon och filsystem

Lär dig att exponera nätverkstjänster i Docker, skapa Docker-nätverk och använda Dockerfiles för att hantera nätverksinställningar.

Repetition av nätverkskoncept

Vad är min IP-adress?

Giltiga portar

Tillgängliggöra nätverkstjänster i Docker

Mappa en port

Flera containrar, samma värdport?

Exponera portar med Dockerfiles

Så många alternativ

Mappa en containerport

Använda efemära portar

Docker-nätverk

Skapa ett Docker-nätverk

Lägga till containrar i ett nätverk

IP-intervall

Ta bort containernätverk

Nätverk

Lär dig använda Dockers avancerade verktyg för avbildningshantering och kompilering för att skapa kompakta och effektiva containeravbildningar. Skapa plattformsoberoende avbildningar som kan köras på olika processorarkitekturer.

Optimera Docker-avbildningar

Hantera dina farhågor

Utforska Docker-avbildningar

Välj den bästa avbildningen

Förstå lager

Lagertårtan

Hur många lager?

Multi-stage-byggen

Enkelstegsbygge

Multi-stage-bygge

Förstå flerstegsbyggen

Multiplattformsbyggen

Steg för multiplattformsbyggen

Bygg för flera plattformar

Skapa avancerade containeravbildningar

Kombinera Dockers funktioner för volymer, nätverk och containerhantering i applikationer med flera containrar via Docker Compose. Uppdatera och hantera driftsättningar via filen docker-compose.yml.

Introduktion till Docker Compose

Hantera en applikation med Docker Compose

Felsökning vid uppstart av applikation

Skapa compose.yaml-filer

Skriva en compose.yaml-fil

Identifiera sektioner

Hur många resurser?

Beroenden och felsökning i Docker Compose

Resursernas uppstartsordning

Beräkning av beroenden

Avstängningsordning

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

Felsökning av beroenden

Skapa en datatjänst i 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


Bygg ett backend för datatjänst

Lägga till en dataklient

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


Använda Docker Compose för att definiera en komplett applikation

Grattis!

Docker Compose

Den här kursen bygger vidare på grunderna i Docker och containerisering från kursen Introduktion till Docker. Vi utökar de koncept och verktyg som behandlades där och introducerar hantering och optimering av containeravbildningar, nätverk, filsystemskommunikation samt stöd för flera plattformar och flera containrar. När du är klar kommer du att kunna:

- Skapa flerstegskompileringar för att optimera storlek, säkerhet och återanvändbarhet hos containeriserade applikationer.
- Använda Dockers nätverksverktyg och nätverkskoncept för att möjliggöra kommunikation mellan containrar och tillhandahålla nätverkstjänster till det lokala nätverket och omvärlden.
- Dela filer och data mellan containrar och värddatorn med hjälp av Dockers filsystemsmonteringar och volymer.
- Skapa driftsättningar med flera containrar via Docker Compose, vilket avsevärt förenklar uppsättningen av komplexa verktyg som är vanliga i data science- och ingenjörsmiljöer.

Du får ut mest av kursen om du redan har arbetat med och byggt några enkla containrar, men vill utöka din verktygslåda för utveckling, testning och distribution. Vi hjälper dig gärna vidare på din väg att lära dig Docker.

Den här kursen bygger vidare på kunskaperna från kursen Introduktion till Docker och går djupare in på containeriseringens koncept och verktyg. Vi kommer att utforska avancerade ämnen som hantering av containeravbilder, nätverk, filsystemskommunikation och utveckling av plattformsoberoende och multi-container-applikationer.
<h2>Optimering av containeriserade applikationer</h2>
Lär dig att skapa flerstegsbyggen för att förbättra storlek, säkerhet och återanvändbarhet hos containeriserade applikationer. Genom praktiska övningar lär du dig tekniker för att optimera containeravbilder och säkerställa effektiv driftsättning och hantering i olika miljöer.
<h2>Förbättra containerdistributioner med Docker Compose</h2>
Upptäck hur du kan dra nytta av Docker-nätverksverktyg och -koncept för att underlätta kommunikation mellan containrar och tillhandahålla nätverkstjänster till både lokala och externa nätverk. Utforska filsystemsmountningar och volymer för sömlös datadelning mellan containrar och värddatorn. Dessutom får du praktisk kunskap i Docker Compose för att orkestrera driftsättningar av applikationer med flera containrar, vilket förenklar uppsättningen av komplexa verktyg som är vanliga i data science- och ingenjörsmiljöer.
<h2>Stärker utveckling och driftsättning</h2>
Den här kursen ger dig de viktigaste färdigheterna för att förbättra dina utvecklings-, testnings- och distributionsprocesser. Även om det inte är nödvändigt får du ut mest av den här kursen om du har arbetat med och byggt några enkla containers. I slutet av kursen kommer du att ha kunskapen och verktygen för att optimera containeriserade applikationer, effektivisera kommunikationen mellan containrar och distribuera applikationer med flera containrar med lätthet, vilket stärker dig på din läranderesa med Docker.

Introduction to Docker

Behärska multi-stage builds, Docker-nätverk och Docker Compose för optimala containerapplikationer!

Docker för medelnivå

Bemästra flerstegsbyggen, Docker-nätverksverktyg och Docker Compose för optimala containeriserade applikationer!

Avstängningsordning

Docker för medelnivå

Interaktiv övning med praktiskt arbete