The Ultimate Docker Container Book : Build, Ship, Deploy, and Scale Containerized Applications with Docker, Kubernetes, and the Cloud.

Format:

Book

Author/Creator:

Schenker, Gabriel N.

Language:

English

Subjects (All):

Software container technologies.

Application software--Development.

Application software.

Physical Description:

1 online resource (768 pages)

Edition:

1st ed.

Place of Publication:

Birmingham : Packt Publishing, Limited, 2026.

Summary:

Master Docker, Kubernetes, and cloud-native container deployment with this hands-on guide.Learn image creation, orchestration, security, monitoring, and real-world production patterns for scalable applications Key Features Learn Docker and Kubernetes from first principles through hands-on, production-focused examples Build secure, scalable.

Contents:

Cover

The Ultimate Docker Container Book

Fourth Edition

Build, ship, deploy, and scale containerized applications with Docker, Kubernetes, and the cloud

Contributors

About the author

About the reviewers

Table of Contents

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Conventions used

Get in touch

Free benefits with your book

How to Unlock

Stay Sharp in Cloud and DevOps - Join 44,000+ Subscribers of CloudPro

Share your thoughts

Part 1

Introduction

Chapter 1: What Are Containers and Why Should I Use Them?

What are containers?

Why are containers important?

What is the benefit of using containers for me or my company?

The Moby project

Docker products

Docker Desktop

Docker Hub

Docker EE

Container architecture

What's new in containerization

Enhanced supply chain security

Debugging and operations in Kubernetes

Docker Desktop extensions

Evolving resource management

Where do we go from here?

Summary

Further reading

Questions

Answers

Get this book's PDF version and more

Chapter 2: Setting Up a Working Environment

Technical requirements

Distinguishing the major operating systems

macOS

Windows

Linux

The Linux command shell

PowerShell for Windows

Installing and using a package manager

Installing Homebrew on macOS

Installing Chocolatey on Windows

Installing Git and cloning the code repository

Choosing and installing a code editor

Installing VS Code on macOS

Installing VS Code on Windows

Installing VS Code on Linux

Installing VS Code extensions

Installing cursor.ai

Installing Docker Desktop on macOS, Windows, or Linux

Testing Docker Engine

Testing Docker Desktop.

Using Docker with WSL 2 on Windows

Installing Docker Toolbox

Enabling Kubernetes on Docker Desktop

Installing Podman

Installing Podman on MacOS

Installing Podman on Windows

Installing Podman on Linux

Installing minikube

Installing minikube on Linux, macOS, and Windows

Installing minikube on macOS using Homebrew

Testing minikube and kubectl

Working with a multi-node minikube cluster

Installing kind

Testing kind and minikube

Join us on Discord

Part 2: Containerization Fundamentals

Chapter 3: Mastering Containers

Running the first container

Starting, stopping, and removing containers

Running a random trivia question container

Listing containers

Stopping and starting containers

Removing containers

Inspecting containers

Executing commands in a running container

Attaching to a running container

Retrieving container logs

Logging drivers

Using a container-specific logging driver

Advanced topic - changing the default logging driver

The anatomy of containers

Architecture

Namespaces

Control groups

Union filesystem

Container plumbing

runc

Containerd

Chapter 4: Creating and Managing Container Images

What are images?

The layered filesystem

The writable container layer

Copy-on-write

Graph drivers

Creating Docker images

Interactive image creation

Using Dockerfiles

The FROM keyword

The RUN keyword

The COPY and ADD keywords

The WORKDIR keyword

The CMD and ENTRYPOINT keywords

A complex Dockerfile

Building an image

Working with multi-stage builds

Dockerfile best practices

Containers are ephemeral.

Leverage the immutability of container image layers

Minimize the number of layers

Keeping container image sizes minimal

Saving and loading images

Containerizing a legacy app using the lift and shift approach

Analyzing external dependencies

Preparing source code and build instructions

Configuration

Secrets

Authoring the Dockerfile

The base image

Assembling the sources

Building the application

Defining the start command

Why bother?

Sharing or shipping images

Tagging an image

Demystifying image namespaces

Explaining official images

Pushing images to a registry

Supply chain security practices

Chapter 5: Data Volumes and Configuration

Creating and mounting data volumes

Modifying the container layer

Creating volumes

Mounting a volume

Removing volumes

Accessing Docker volumes

Sharing data between containers

Using host volumes

Defining volumes in images

Configuring containers

Defining environment variables for containers

Using configuration files

Defining environment variables in container images

Environment variables at build time

Persistent storage and stateful container patterns

Understanding persistent storage in Docker

Patterns for managing stateful containers

Best practices for persistent storage

Chapter 6: Debugging Code Running in Containers

Evolving and testing code running in a container

Mounting evolving code in the running container

Auto-restarting code upon changes

Auto-restarting for Node.js

Auto-restarting for Java and Spring Boot

Installing JDK 21 on macOS

Installing JDK 21 on Windows.

Installing Java Extensions for VS Code

Auto-restarting for Python

Prerequisites

Auto-restarting for .NET

Line-by-line code debugging inside a container

Debugging a Node.js application

Debugging a .NET application

Instrumenting your code to produce meaningful logging information

Instrumenting a Python application

Instrumenting a .NET C# application

Using OpenTelemetry and Jaeger to monitor and troubleshoot

Instrumenting a .NET application

Instrumenting a Java application

Chapter 7: Testing Applications Running in Containers

Benefits of testing in containers

Why do we test?

Manual versus automated testing

Why do we test in containers?

Types of tests for containerized apps

Unit tests

Integration tests

Acceptance tests

Tools, frameworks, and test environments

Implementing a sample component

Implementing and running unit and integration tests

Implementing and running black-box tests

Best practices for setting up a testing environment

Tips for debugging and troubleshooting issues

Challenges and considerations when testing applications running in containers

Case studies

Chapter 8: Increasing Productivity with Docker Tips and Tricks

Keeping your Docker environment clean

Using a .dockerignore file

Executing simple admin tasks in a container

Running a Perl script

Running a Python script

Limiting the resource usage of a container

Limiting memory resources

Limiting CPU resources

Limiting block I/O (disk I/O) resources

Limiting process IDs

Avoiding running a container as root

Step 1: Running the container as root (default).

Step 2: Running the container as non-root

Running Docker CLI commands from within Docker

Special case: Docker-in-Docker

Automating a pipeline

Optimizing your build process

Scanning for vulnerabilities and secrets

Using Snyk to scan a Docker image

Using Docker Scout to scan a Docker image for vulnerabilities

Running your development environment in a container

Part 3

Orchestration Fundamentals

Chapter 9: Learning about Distributed Application Architecture

What is a distributed application architecture?

Defining the terminology

Patterns and best practices

Loosely coupled components

Stateful versus stateless

Service discovery

Routing

Load balancing

Defensive programming

Retries

Logging

Error handling

Redundancy

Health checks

Circuit breaker pattern

Rate limiter

Bulkhead

Running in production

Tracing

Monitoring

Application updates

Rolling updates

Blue-green deployments

Canary releases

Irreversible data changes

Changing the data structure at scale

Rollback and roll forward

Modern microservice patterns

Chapter 10: Using Single-Host Networking

Dissecting the container network model

Network firewalling

IPv4, IPv6, and dual-stack networking

nftables versus iptables

Best practice: Least-privilege networking

Working with the bridge network

Creating a custom bridge network

IPv6 and dual-stack bridge networks

Configuring the MTU and other options

Attaching containers to custom bridge networks

The host and null network types

The host network

The null (none) network

Running in an existing network namespace.

How Kubernetes uses this concept.

Notes:

Description based on publisher supplied metadata and other sources.

Part of the metadata in this record was created by AI, based on the text of the resource.

ISBN:

1-80580-438-3

9781805804383

OCLC:

1581934625