This chapter covers new Docker commands and details on how to share data between host system and containerized applications. Learn when and how to use persistent volumes and access host filesystems.

Intermediate Docker Commands

Help at a glance

Existing containers

Automatic container cleanup

Mounting the host filesystem

Passing a file to a running container

Gone, but not forgotten

Different methods, same result

Persistent volumes

Creating a container volume

Different containers, same volume

Commands and filesystems

Learn to expose networking services in Docker, create Docker networks, and use Dockerfiles to maintain network settings.

Networking refresher

What's my IP?

Valid ports

Making network services available in Docker

Mapping a port

Multiple containers, same host port?

Exposing ports with Dockerfiles

So many options

Mapping a container port

Using ephemeral mapping

Docker networks

Creating a docker network

Adding containers to a network

IP Ranges

Removing container networks

Networking

Learn to use Docker's advanced image management and build tools to create compact effective container images. Create multi-platform images capable of running on different processor architectures.

Mengoptimalkan image Docker

Batasi kekhawatiran Anda

Eksplorasi image Docker

Menentukan image terbaik untuk digunakan

Memahami layer

Kue lapis (layer)

Ada berapa layer?

Build multi-tahap

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


Build satu tahap

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.


Langkah build Docker engine

Memahami multi-stage builds

Build multi-platform

Urutan build multi-platform

Langkah multi-platform

#!/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"


Building advanced container images

Combine the the volume, networking, and container handling capabilities of Docker into multi-container applications using Docker Compose. Update and manage application deployments via the docker-compose.yml file.

Introduction to Docker Compose

Managing an application with Docker Compose

Troubleshooting application startup

Creating compose.yaml files

Writing a compose.yaml file

Identifying sections

How many resources?

Dependencies and troubleshooting in Docker Compose

Dependency calculation

Shutdown order

Troubleshooting dependencies

Creating a data service within Docker

Building a data service backend

Adding a data client

Using Docker Compose to define a full application

Congratulations!

Docker Compose

Kursus ini membangun dasar-dasar pembelajaran Docker dan kontainerisasi yang telah dibahas dalam kursus Introduction to Docker. Kami memperluas konsep dan alat dalam kursus tersebut, menambahkan gagasan tentang pengelolaan dan optimalisasi citra kontainer, jaringan, komunikasi sistem berkas, serta aplikasi multi-platform dan multi-kontainer. Setelah selesai, Anda akan dapat:

- Membuat build multi-tahap untuk mengoptimalkan ukuran, keamanan, dan ketergunaan kembali aplikasi yang dikontainerkan.
- Menggunakan alat dan konsep jaringan Docker untuk menambahkan komunikasi antar kontainer serta menyediakan layanan jaringan ke jaringan lokal dan dunia luar.
- Berbagi berkas dan data antara kontainer dan mesin host menggunakan mount sistem berkas dan volume Docker.
- Membuat penerapan aplikasi multi-kontainer menggunakan Docker Compose, yang sangat menyederhanakan penyiapan alat-alat kompleks yang umum di lingkungan data science dan rekayasa.

Anda akan mendapatkan manfaat terbesar dari kursus ini jika Anda sudah pernah bekerja dengan dan membangun beberapa kontainer sederhana, tetapi ingin menambah peranti untuk pengembangan, pengujian, dan distribusi. Kami berharap dapat membimbing Anda dalam perjalanan mempelajari Docker.

Kursus ini memperluas pengetahuan yang diperoleh dari kursus Pengenalan Docker, dengan membahas lebih dalam konsep dan alat-alat kontainerisasi. Kami akan membahas topik-topik lanjutan seperti pengelolaan gambar kontainer, jaringan, komunikasi sistem berkas, dan pengembangan aplikasi multi-platform dan multi-kontainer.
<h2>Optimasi Aplikasi Berbasis Kontainer</h2>
Pelajari cara membuat build bertahap untuk meningkatkan ukuran, keamanan, dan kemudahan penggunaan kembali aplikasi yang dikontainerisasi. Melalui latihan praktis, kuasai teknik untuk mengoptimalkan gambar kontainer, memastikan deployment dan pengelolaan yang efisien di berbagai lingkungan.
<h2>Meningkatkan Deploymen Kontainer dengan Docker Compose</h2>
Pelajari cara memanfaatkan alat dan konsep jaringan Docker untuk memfasilitasi komunikasi antar-kontainer dan menyediakan layanan jaringan untuk jaringan lokal maupun eksternal. Jelajahi mount sistem berkas dan volume untuk berbagi data secara lancar antara kontainer dan mesin host. Selain itu, kuasai Docker Compose untuk mengelola deployment aplikasi multi-container, yang memudahkan pengaturan alat-alat kompleks yang umum digunakan dalam lingkungan data science dan engineering.
<h2>Memperkuat Pengembangan dan Implementasi</h2>
Kursus ini membekali Anda dengan keterampilan esensial untuk meningkatkan proses pengembangan, pengujian, dan distribusi Anda. Meskipun tidak wajib, Anda akan mendapatkan manfaat maksimal dari kursus ini jika Anda telah bekerja dengan dan membangun beberapa kontainer sederhana. Pada akhir kursus ini, Anda akan memiliki pengetahuan dan alat yang diperlukan untuk mengoptimalkan aplikasi yang dikontainerisasi, memperlancar komunikasi antar kontainer, dan mengimplementasikan aplikasi multi-kontainer dengan mudah, sehingga Anda dapat melanjutkan perjalanan belajar Docker Anda dengan lebih percaya diri.

Introduction to Docker

Kuasi multi-stage builds, alat jaringan Docker, dan Docker Compose untuk aplikasi optimal!

Docker Tingkat Menengah

Kuasai proses pembangunan multi-tahap, alat jaringan Docker, dan Docker Compose untuk aplikasi kontainer yang optimal!

Kontainerisasi dan Virtualisasi dengan Docker dan Kubernetes

Docker engine menarik citra `golang:1.21` dari sebuah repositori.

Docker membuat instance kontainer `golang:1.21` dan menyalin berkas sumber ke dalamnya.

Docker engine mengeksekusi perintah untuk membangun aplikasi Go.

Citra kontainer baru dibuat hanya menggunakan aplikasi Go yang baru dikompilasi.

Memahami multi-stage builds

Docker Tingkat Menengah

Latihan interaktif praktis