The ultimate Docker container book : build, test, ship, and run containers with Docker and Kubernetes / Gabriel N. Schenker.

Format:

Book

Author/Creator:

Schenker, Gabriel N., author.

Language:

English

Subjects (All):

Application software--Development.

Application software.

Cloud computing.

Physical Description:

1 online resource (626 pages)

Edition:

Third edition.

Place of Publication:

Birmingham, England : Packt Publishing Ltd., [2023]

System Details:

Mode of access: World Wide Web.

Biography/History:

Schenker Dr. Gabriel N. : Dr. Gabriel N. Schenker has more than 25 years of experience as an independent consultant, architect, leader, trainer, mentor, and developer. Currently, Gabriel works as Lead Solution Architect at Techgroup Switzerland. Prior to that, Gabriel worked as Lead Curriculum Developer at Docker and at Confluent. Gabriel has a Ph. D. in Physics, and he is a Docker Captain, a Certified Docker Associate, a Certified Kafka Developer and Operator, and an ASP Insider. When not working, Gabriel enjoys time with his wonderful wife Veronicah and his children.

Summary:

The Ultimate Docker Container Book, 3rd edition enables you to leverage Docker containers for streamlined software development. You’ll uncover Docker fundamentals and how containers improve software supply chain efficiency and enhance security. You’ll start by learning practical skills such as setting up Docker environments, handling stateful components, running and testing code within containers, and managing Docker images. You’ll also explore how to adapt legacy applications for containerization and understand distributed application architecture. Next, you’ll delve into Docker's networking model, software-defined networks for secure applications, and Docker compose for managing multi-service applications along with tools for log analysis and metrics. You’ll further deepen your understanding of popular orchestrators like Kubernetes and Docker swarmkit, exploring their key concepts, and deployment strategies for resilient applications. In the final sections, you’ll gain insights into deploying containerized applications on major cloud platforms, including Azure, AWS, and GCE and discover techniques for production monitoring and troubleshooting. By the end of this book, you’ll be well-equipped to manage and scale containerized applications effectively.

Contents:

Cover

Title Page

Copyright and Credits

Contributors

Table of Contents

Preface

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 for my company?

The Moby project

Docker products

Docker Desktop

Docker Hub

Docker Enterprise Edition

Container architecture

Summary

Further reading

Questions

Answers

Chapter 2: Setting Up a Working Environment

Technical requirements

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 Docker Desktop on macOS or Windows

Testing Docker Engine

Testing Docker Desktop

Installing Docker Toolbox

Enabling Kubernetes on Docker Desktop

Installing minikube

Installing minikube on Linux, macOS, and Windows

Testing minikube and kubectl

Working with a multi-node minikube cluster

Installing Kind

Testing Kind

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

Exec into 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

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

Saving and loading images

Lift and shift - containerizing a legacy app

Analyzing external dependencies

Source code and build instructions

Configuration

Secrets

Authoring the Dockerfile

Why bother?

Sharing or shipping images

Tagging an image

Demystifying image namespaces

Explaining official images

Pushing images to a registry

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

Chapter 6: Debugging Code Running in Containers

Evolving and testing code running in a container

Mounting evolving code into the running container

Auto-restarting code upon changes

Auto-restarting for Node.js

Auto-restarting for Java and Spring Boot

Auto-restarting for Python

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 Jaeger to monitor and troubleshoot

Chapter 7: Testing Applications Running in Containers

Benefits of testing applications in containers

Why do we test?

Manual versus automated testing

Why do we test in containers?

Different types of testing

Unit tests

Integration tests

Acceptance tests

Commonly used tools and technologies

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

Avoiding running a container as root

Running Docker from within Docker

Optimizing your build process

Scanning for vulnerabilities and secrets

Using Snyk to scan a Docker image

Using docker scan 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

Redundancy

Health checks

Circuit breaker pattern

Running in production

Logging

Tracing

Monitoring

Application updates

Chapter 10: Using Single-Host Networking

Dissecting the container network model

Network firewalling

Working with the bridge network

The host and null networks

The host network

The null network

Running in an existing network namespace

Managing container ports

HTTP-level routing using a reverse proxy

Containerizing the monolith

Extracting the first microservice

Using Traefik to reroute traffic

Chapter 11: Managing Containers with Docker Compose

Demystifying declarative versus imperative orchestration of containers

Running a multi-service app

Building images with Docker Compose

Running an application with Docker Compose

Scaling a service

Building and pushing an application

Using Docker Compose overrides

Chapter 12: Shipping Logs and Monitoring Containers

Why is logging and monitoring important?

Shipping containers and Docker daemon logs

Shipping container logs

Shipping Docker daemon logs

Querying a centralized log

Step 1 - accessing Kibana

Step 2 - setting up an index pattern

Step 3 - querying the logs in Kibana

Step 4 - visualizing the logs

Collecting and scraping metrics

Step 1 - running cAdvisor in a Docker container

Step 2 - setting up and running Prometheus

Monitoring a containerized application

Step 1 - setting up Prometheus.

Step 2 - instrumenting your application with Prometheus metrics

Step 3 - configuring Prometheus to scrape your application metrics

Step 4 - setting up Grafana for visualization

Step 5 - setting up alerting (optional)

Step 6 - monitoring your containerized application

Chapter 13: Introducing Container Orchestration

What are orchestrators and why do we need them?

The tasks of an orchestrator

Reconciling the desired state

Replicated and global services

Scaling

Self-healing

Data persistence and storage management

Zero downtime deployments

Affinity and location awareness

Security

Introspection

Overview of popular orchestrators

Kubernetes

Docker Swarm

Apache Mesos and Marathon

Amazon ECS

AWS EKS

Microsoft ACS and AKS

Chapter 14: Introducing Docker Swarm

The Docker Swarm architecture

Swarm nodes

Stacks, services, and tasks

Services

Tasks

Stacks

Multi-host networking

Creating a Docker Swarm

Creating a local single-node swarm

Using PWD to generate a Swarm

Creating a Docker Swarm in the cloud

Deploying a first application

Creating a service

Inspecting the service and its tasks

Testing the load balancing

Logs of a service

Deleting a service or a stack

Deploying a multi-service stack

Removing the swarm in AWS

Chapter 15: Deploying and Running a Distributed Application on Docker Swarm

The swarm routing mesh

Zero-downtime deployment

Popular deployment strategies

Rolling updates

Rolling back

Blue-green deployments

Canary releases

Storing configuration data in the swarm.

Protecting sensitive data with Docker secrets.

Notes:

Includes index.

Includes bibliographical references and index.

Description based on print version record.

ISBN:

9781804613184

1804613185

OCLC:

1396227214