Learn Docker fundamentals of Docker 18.x : everything you need to know about containerizing your applications and running them in production
Enhance your software deployment workflow using containers About This Book Get up-and-running with basic to advanced concepts of Docker Get acquainted with concepts such as Docker containers, Docker images, orchestrators and so on. Practical test-based approach to learning a prominent containerizati...
| Otros Autores: | |
|---|---|
| Formato: | Libro electrónico |
| Idioma: | Inglés |
| Publicado: |
Birmingham ; Mumbai :
Packt Publishing
2018.
|
| Edición: | 1st edition |
| Materias: | |
| Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009631488806719 |
Tabla de Contenidos:
- Cover
- Title Page
- Copyright and Credits
- Packt Upsell
- Contributors
- Table of Contents
- Preface
- Chapter 1: What Are Containers and Why Should I Use Them?
- Technical requirements
- What are containers?
- Why are containers important?
- What's the benefit for me or for my company?
- The Moby project
- Docker products
- Docker CE
- Docker EE
- The container ecosystem
- Container architecture
- Summary
- Questions
- Further reading
- Chapter 2: Setting up a Working Environment
- Technical requirements
- The Linux command shell
- PowerShell for Windows
- Using a package manager
- Installing Homebrew on a Mac
- Installing Chocolatey on Windows
- Choosing a code editor
- Docker Toolbox
- Docker for Mac and Docker for Windows
- Installing Docker for Mac
- Installing Docker for Windows
- Using docker-machine on Windows with Hyper-V
- Minikube
- Installing Minikube on Mac and Windows
- Testing Minikube and kubectl
- Summary
- Questions
- Further reading
- Chapter 3: Working with Containers
- Technical requirements
- Running the first container
- Starting, stopping, and removing containers
- Running a random quotes 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
- Anatomy of containers
- Architecture
- Namespaces
- Control groups (cgroups)
- Union filesystem (UnionFS)
- Container plumbing
- Runc
- Containerd
- Summary
- Questions
- Further reading
- Chapter 4: Creating and Managing Container Images
- What are images?
- The layered filesystem
- The writable container layer
- Copy-on-write
- Graph drivers.
- Creating 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
- Multistep builds
- Dockerfile best practices
- Saving and loading images
- Sharing or shipping images
- Tagging an image
- Image namespaces
- Official images
- Pushing images to a registry
- Summary
- Questions
- Further reading
- Chapter 5: Data Volumes and System Management
- Technical requirements
- Creating and mounting data volumes
- Modifying the container layer
- Creating volumes
- Mounting a volume
- Removing volumes
- Sharing data between containers
- Using host volumes
- Defining volumes in images
- Obtaining Docker system information
- Listing resource consumption
- Pruning unused resources
- Pruning containers
- Pruning images
- Pruning volumes
- Pruning networks
- Pruning everything
- Consuming Docker system events
- Summary
- Questions
- Further reading
- Chapter 6: 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
- Running in production
- Logging
- Tracing
- Monitoring
- Application updates
- Rolling updates
- Blue-green deployments
- Canary releases
- Irreversible data changes
- Rollback
- Summary
- Questions
- Further reading
- Chapter 7: Single-Host Networking
- Technical requirements
- The container network model
- Network firewalling
- The bridge network
- The host network
- The null network.
- Running in an existing network namespace
- Port management
- Summary
- Questions
- Further reading
- Chapter 8: Docker Compose
- Technical requirements
- Demystifying declarative versus imperative
- Running a multi-service app
- Scaling a service
- Building and pushing an application
- Summary
- Questions
- Further reading
- Chapter 9: Orchestrators
- What are orchestrators and why do we need them?
- The tasks of an orchestrator
- Reconciling the desired state
- Replicated and global services
- Service discovery
- Routing
- Load balancing
- Scaling
- Self-healing
- Zero downtime deployments
- Affinity and location awareness
- Security
- Secure communication and cryptographic node identity
- Secure networks and network policies
- Role-based access control (RBAC)
- Secrets
- Content trust
- Reverse uptime
- Introspection
- Overview of popular orchestrators
- Kubernetes
- Docker Swarm
- Apache Mesos and Marathon
- Amazon ECS
- Microsoft ACS
- Summary
- Questions
- Further reading
- Chapter 10: Introduction to Docker Swarm
- Architecture
- Swarm nodes
- Swarm managers
- Swarm workers
- Stacks, services, and tasks
- Services
- Task
- Stack
- Multi-host networking
- Creating a Docker Swarm
- Creating a local single node swarm
- Creating a local swarm in VirtualBox or Hyper-V
- Using Play with Docker (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
- Logs of a service
- Reconciling the desired state
- Deleting a service or a stack
- Deploying a multi-service stack
- The swarm routing mesh
- Summary
- Questions
- Further reading
- Chapter 11: Zero Downtime Deployments and Secrets
- Technical requirements
- Zero downtime deployment
- Popular deployment strategies
- Rolling updates.
- Health checks
- Rollback
- Blue-green deployments
- Canary releases
- Secrets
- Creating secrets
- Using a secret
- Simulating secrets in a development environment
- Secrets and legacy applications
- Updating secrets
- Summary
- Questions
- Further reading
- Chapter 12: Introduction to Kubernetes
- Technical requirements
- Architecture
- Kubernetes master nodes
- Cluster nodes
- Introduction to Minikube
- Kubernetes support in Docker for Desktop
- Pods
- Comparing Docker container and Kubernetes pod networking
- Sharing the network namespace
- Pod life cycle
- Pod specification
- Pods and volumes
- Kubernetes ReplicaSet
- ReplicaSet specification
- Self-healing
- Kubernetes deployment
- Kubernetes service
- Context-based routing
- Comparing SwarmKit with Kubernetes
- Summary
- Questions
- Further reading
- Chapter 13: Deploying, Updating, and Securing an Application with Kubernetes
- Technical requirements
- Deploying a first application
- Deploying the web component
- Deploying the database
- Streamlining the deployment
- Zero downtime deployments
- Rolling updates
- Blue-green deployment
- Kubernetes secrets
- Manually defining secrets
- Creating secrets with kubectl
- Using secrets in a pod
- Secret values in environment variables
- Summary
- Questions
- Further reading
- Chapter 14: Running a Containerized App in the Cloud
- Technical requirements
- Deploying our application into AWS ECS
- Introduction to ECS
- Creating a Fargate ECS cluster of AWS
- Authoring a task definition
- Running a task in ECS
- Modifying the task definition
- Adding the database component to the application
- Deploying and using Docker EE on AWS
- Provisioning the infrastructure
- Installing Docker
- Installing Docker UCP
- Remote admin the UCP cluster
- Deploying to Docker Swarm.
- Deploying to Kubernetes
- A short peek into Azure's container offerings
- A short peek into Google's container offerings
- Summary
- Questions
- Further reading
- Assessment
- Other Books You May Enjoy
- Index.
