Containers for Developers Handbook: A practical guide to developing and delivering applications using software containers

Cover
Title Page
Copyright
Dedication
Contributors
Table of Contents
Preface
Part 1:Key Concepts of Containers
Chapter 1: Modern Infrastructure and Applications with Docker
	Technical requirements
	From monoliths to distributed microservice architectures
		Exploring monolithic applications
		Virtual machines
		Three-tier architecture
		Microservices architecture
	Developing distributed applications
	What are containers?
		Understanding the main concepts of containers
		Understanding dynamism in container-based applications
		Tools for managing containers
	Comparing virtualization and containers
	Building, sharing, and running containers
	Explaining Windows containers
	Improving security using software containers
	Labs
		Installing Docker Desktop
	Summary
Chapter 2: Building Docker Images
	Technical requirements
	Understanding how copy-on-write filesystems work
	Creating container images
		Using Dockerfiles to create container images
		Creating container images interactively
		Creating images from scratch
	Understanding common Dockerfile keys
		FROM
		ARG
		WORKDIR
		COPY and ADD
		RUN
		USER
		ENTRYPOINT
		EXPOSE
		HEALTHCHECK
		VOLUME
	The command line for creating images
		Actions for creating images
		Managing container images
		Actions for sharing images
	Advanced image creation techniques
	Best practices for container image creation
	Labs
		Caching layers
		Executing a multi-stage build process
		Building images for different architectures
	Summary
Chapter 3: Sharing Docker Images
	Technical requirements
	Container image registries and repositories
		What is a registry?
		Understanding how image registries work
		Searching in repositories
	Improving security by signing container images
	Scanning image content for vulnerabilities
	Labs
		Deploying and using your own local registry
		Signing images with Cosign
		Improving security by using image content vulnerability scanners
	Summary
Chapter 4: Running Docker Containers
	Technical requirements
	Understanding Docker software container objects
	Learning about using the command line to work with containers
	Limiting container access to host resources
		Network isolation
		Managing persistent data with containers
		Limiting access to host hardware resources
		Extending access to host resources
	Managing container behavior
	Container runtime maintenance tasks
		Pruning container objects
		Configuring container runtime logging
	Labs
		Reviewing container networking concepts
		Access to container services
		Exposing applications
		Limiting containers’ resource usage
		Avoiding the use of root users inside containers
		Cleaning the container runtime
	Summary
Chapter 5: Creating Multi-Container Applications
	Technical requirements
	Installing and using Docker Compose
	Introducing the Docker Compose file syntax
		YAML file definition keys
	Building and sharing multi-container applications
	Running and debugging multi-container applications
	Managing multiple environments with Docker Compose
	Labs
		Deploying a simple demo application
		Deploying another project using the same Compose YAML file
		Removing all projects
	Summary
Part 2:Container Orchestration
Chapter 6: Fundamentals of Container Orchestration
	Introducing the key concepts of orchestration
	Understanding stateless and stateful applications
		Stateful applications
		Stateless applications
	Exploring container orchestrators
		Kubernetes
		Docker Swarm
		Nomad
		Apache Mesos
		Cloud vendor-specific orchestration platforms
	Summary
Chapter 7: Orchestrating with Swarm
	Technical requirements
	Deploying a Docker Swarm cluster
		Understanding Docker Swarm’s architecture
		Docker Swarm manager nodes
		Docker Swarm worker nodes
		Creating a Docker Swarm cluster
	Providing high availability with Docker Swarm
	Creating tasks and services for your applications
	A review of stacks and other Docker Swarm resources
		Secrets
		Configs
	Networking and exposing applications with Docker Swarm
		Understanding the Docker Swarm overlay network
		Using service discovery and internal load balancing
		Publishing your applications
	Updating your application’s services
	Labs
		Deploying a single-node Docker Swarm cluster
		Reviewing the main features of Docker Swarm services
		Deploying a complete application with Docker
	Summary
Chapter 8: Deploying Applications with the Kubernetes Orchestrator
	Technical requirements
	Introducing the main features of Kubernetes
		Comparing Kubernetes and Docker Swarm
		Exploring the control plane
	Understanding Kubernetes’ HA
		Kubeadm Kubernetes deployment
	Interacting with Kubernetes using kubectl
	Deploying a functional Kubernetes cluster
		Docker Desktop
		Rancher Desktop
		Minikube
		Alternative Kubernetes desktop deployments
	Creating Pods and Services
		Pods
		Services
	Deploying orchestrated resources
		ReplicaSets
		Deployments
		DaemonSets
		StatefulSets
		Jobs
		CronJobs
		ReplicationControllers
	Improving your applications’ security with Kubernetes
	Labs
		Deploying a Minikube cluster with two nodes
		Interacting with the Minikube deployed cluster
		Exposing a Pod with a NodePort Service
	Summary
Part 3:Application Deployment
Chapter 9: Implementing Architecture Patterns
	Technical requirements
	Applying Kubernetes resources to common application patterns
		Pods
		ReplicaSets
		ReplicationControllers
		Deployments
		StatefulSets
		DaemonSets
		Jobs
		CronJobs
		Ensuring resilience and high availability with Kubernetes resources
	Understanding advanced Pod application patterns
		Init containers
		Sidecar containers
		Ambassador containers
		Adaptor containers
	Verifying application health
		Understanding the execution of probes
		Termination of Pods
		Container life cycle hooks
	Resource management and scalability
		Horizontal Pod autoscaling
	Improving application security with Pods
		Security contexts
		Security best practices
	Labs
	Summary
Chapter 10: Leveraging Application Data Management in Kubernetes
	Technical requirements
	Understanding the data within your application
	Applying configurations using ConfigMaps
		Using the downward API to inject configuration data
	Managing sensitive data using Secret resources
	Managing stateless and stateful data
		Using volumes for storing data
	Enhancing storage management in Kubernetes with PV resources
		Provisioning and decommissioning storage
	Labs
	Summary
Chapter 11: Publishing Applications
	Technical requirements
	Understanding Kubernetes features for publishing applications cluster-wide
	Proxying and forwarding applications for debugging
		Kubernetes client proxy feature
		Kubernetes client port-forward feature
	Using the host network namespace for publishing applications
		Using the hostNetwork key
		Using hostPort
	Publishing applications with Kubernetes’ NodePort feature
	Providing access to your Services with LoadBalancer Services
	Understanding Ingress Controllers
		Deploying an Ingress Controller
		Ingress resources
	Improving our applications’ security
		Network policies
		Service mesh
	Labs
		Improving application access by deploying your own Ingress Controller
		Publishing the simplestlab application on Kubernetes using an Ingress Controller
	Summary
Chapter 12: Gaining Application Insights
	Technical requirements
	Understanding your application’s behavior
	Obtaining access to your Kubernetes resources
		Understanding Kubernetes operators
	Monitoring your application’s metrics
		Exploring Prometheus architecture
		Installing Prometheus
		Reviewing the Prometheus environment
		Understanding how Prometheus manages metrics data
		Scraping metrics with Prometheus
	Logging your application’s important information
		Installing and configuring Loki and Promtail
	Load testing your applications
	Adding instrumentation to your application’s code
		Reviewing the OpenTelemetry demo
	Labs
	Summary
Part 4:Improving Applications’ Development Workflow
Chapter 13: Managing the Application Life Cycle
	Technical requirements
	Reviewing the application life cycle
		Planning a software solution
		Developing the application’s components
		Testing your application
		Deploying the solution
		Maintaining the application
	Shifting our application’s security left
		Software life cycle methodologies
		Security at the application level
		Introducing linters
	Understanding CI patterns
		Versioning the code
		Introducing DevOps methodology
		Building artifacts
		Testing your application’s components
		Monitoring the build processes and tests
		Sharing information about the development process
		Excluding configurations from code
	Automating continuous application deployment
	Orchestrating CI/CD with Kubernetes
		Understanding the CI component of the workflow
		Using Helm to package our application’s resource manifests
		Adding CD to the workflow
	Labs
	Summary
Index
About Packt
Other Books You May Enjoy