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

package main
import "fmt"

func main() {
  fmt.Println("Application running...")
}


FROM golang:1.21-alpine3.19
WORKDIR /src
COPY /src/main.go /src/main.go

# Build the go application from source code
RUN go build -o /bin/app_runner /src/main.go

CMD ["/bin/app_runner"]


Run the following commands:
  - docker build . -t single-stage-app
  - docker run single-stage-app
  - docker images
Check the size of the single-stage-app image


Enkelstegsbygge

FROM golang:1.21-alpine3.19 AS gobuild

WORKDIR /src
COPY /src/main.go /src/main.go

# Build the go application from source code
RUN go build -o /bin/app_runner /src/main.go

# Create application in standalone container
# Update with the image name from instructions

FROM ____

# Update with name of previous build stage
COPY --from=____ /bin/app_runner /bin/app_runner

CMD ["/bin/app_runner"]


FROM golang:1.21-alpine3.19 AS gobuild

WORKDIR /src
COPY src/main.go /src/main.go

# Build the go application from source code
RUN go build -o /bin/app_runner /src/main.go

# Create application in standalone container
# Update with the image name from instructions

FROM scratch

# Update with name of previous build stage
COPY --from=gobuild /bin/app_runner /bin/app_runner

CMD ["/bin/app_runner"]


Update the Dockerfile as shown in the example.

Once complete, run the following commands in the terminal:

- docker build . -t multi-stage-app
- docker run multi-stage-app
- docker images

Check the size of the single-stage-app and multi-stage-app
containers.


Multi-stage-bygge

Docker-motorns byggsteg

Förstå flerstegsbyggen

Multiplattformsbyggen

Ordning för multiplattformsbygge

Steg för multiplattformsbyggen

#!/bin/bash

# Note this is an example of string concatenation in jq
#
# There is not a Platform attribute returned by docker image inspect
# so we create our own. This is simply a string returned as Platform,
# consisting of the .Os attribute and the .Architecture attribute joined
# with a slash to produce the Platform field.
#
# This is outside the realm of the course, but is hopefully a further
# example of the power available within the jq tool.

docker image inspect multi-platform-app | jq '.[0] | {Platform: (.Os + "/" + .Architecture)}'


# Update the FROM line to support a multi-platform build
FROM ____=$BUILDPLATFORM golang:1.21-alpine3.19 AS gobuild

WORKDIR /src
COPY src/main.go /src/main.go

# Define the option to pull environment variables from the host
____ TARGETOS TARGETARCH

# Build the go application from source code
RUN env GOOS=$TARGETOS GOARCH=$TARGETARCH go build -o /bin/app_runner /src/main.go

# Create application in standalone container
# Update with the image name from instructions

FROM ____

# Update with name of previous build stage
COPY --from=____ /bin/app_runner /bin/app_runner

CMD ["/bin/app_runner"]


# Update the FROM line to support a multi-platform build
FROM --platform=$BUILDPLATFORM golang:1.21-alpine3.19 AS gobuild

WORKDIR /src
COPY src/main.go /src/main.go

# Define the option to pull environment variables from the host
ARG TARGETOS TARGETARCH

# Build the go application from source code
RUN env GOOS=$TARGETOS GOARCH=$TARGETARCH go build -o /bin/app_runner /src/main.go

# Create application in standalone container
# Update with the image name from instructions

FROM scratch

# Update with name of previous build stage
COPY --from=gobuild /bin/app_runner /bin/app_runner

CMD ["/bin/app_runner"]


Update the Dockerfile as shown in the example.

Once complete, run the following command in the terminal:

- docker buildx build --platform linux/arm64 . -t multi-platform-app 

Verify the platform image built as expected by running the command:

./check_platform.sh

in the terminal window and verify that it returns "linux/arm64"


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

Beräkning av beroenden

Avstängningsordning

Felsökning av beroenden

Skapa en datatjänst i Docker

Bygg ett backend för datatjänst

Lägga till en dataklient

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!

Hur många lager?

Docker för medelnivå

Interaktiv övning med praktiskt arbete