Index
A
- Accelerated Processing Unit (APU) / Affinity and location awareness
- Amazon ECS / Amazon ECS
- Apache Mesos / Apache Mesos and Marathon
- application
- deploying / Deploying a first application
- web component, deploying / Deploying the web component
- database, deploying / Deploying the database
- deployment, streamlining / Streamlining the deployment
- deploying, into AWS ECS / Deploying our application into AWS ECS
- task definition, authoring / Authoring a task definition
- task definition, modifying / Modifying the task definition
- database component, adding / Adding the database component to the application
- application updates
- rolling updates / Rolling updates
- blue-green deployment / Blue-green deployments
- canary releases / Canary releases
- irreversible data changes / Irreversible data changes
- rollback / Rollback
- auto scaling group (ASG) / Provisioning the infrastructure
- AWS
- Docker EE, deploying / Deploying and using Docker EE on AWS
- Docker EE, using / Deploying and using Docker EE on AWS
- Azure container / A short peek into Azure’s container offerings
- Azure Container Instances / A short peek into Azure’s container offerings
- Azure Container Service (ACS) / Overview of popular orchestrators, A short peek into Azure’s container offerings
- Azure Kubernetes Service (AKS) / Microsoft ACS
B
- bare metal / Defining the terminology
- Bourne shell (sh) / The Linux command shell
- bridge network / The bridge network
C
- certificate authority (CA) / Creating a local single node swarm
- cgroups / Anatomy of containers
- Cheat Sheet
- reference link / The Linux command shell
- chief information officer (CIO) / Security
- chief technology officer (CTO) / Security
- Chocolatey
- about / Using a package manager
- installing, on Windows / Installing Chocolatey on Windows
- reference link / Installing Chocolatey on Windows
- circuit breaker pattern / Circuit breaker pattern
- client bundle / Remote admin the UCP cluster
- cloud
- Docker Swarm, creating / Creating a Docker Swarm in the cloud
- Cloud Native Computing Foundation (CNCF) / The Moby project, Kubernetes
- cluster communication
- management plane / Secure communication and cryptographic node identity
- control plane / Secure communication and cryptographic node identity
- data plane / Secure communication and cryptographic node identity
- cluster nodes / Cluster nodes
- code editor
- selecting / Choosing a code editor
- command-line interface (CLI) / Starting, stopping, and removing containers
- Community Edition (CE) / Docker products
- consensus group / Swarm managers
- container-specific logging driver
- container execution
- network namespace, creating / Running in an existing network namespace
- container images
- about / What are images?
- layered filesystem / The layered filesystem
- writable container layer / The writable container layer
- copy-on-write technique / Copy-on-write
- graph drivers / Graph drivers
- creating / Creating images
- creating, interactively / Interactive image creation
- Dockerfiles, using / Using Dockerfiles
- saving / Saving and loading images
- loading / Saving and loading images
- Container Network Interface (CNI) / Architecture
- Container Network Model (CNM)
- about / The container network model
- sandbox / The container network model
- endpoint / The container network model
- network / The container network model
- container plumbing
- about / Container plumbing
- Runc / Runc
- containerd / Containerd
- container runtime / Cluster nodes
- containers
- about / What are containers?
- need for / Why are containers important?
- benefits / What's the benefit for me or for my company?
- ecosystem / The container ecosystem
- architecture / Container architecture
- executing / Running the first container
- starting / Starting, stopping, and removing containers, Stopping and starting containers
- stopping / Starting, stopping, and removing containers, Stopping and starting containers
- removing / Starting, stopping, and removing containers, Removing containers
- listing / Listing containers
- inspecting / Inspecting containers
- exec command, executing / Exec into a running container
- attach command, using / Attaching to a running container
- logs, retrieving / Retrieving container logs
- anatomy / Anatomy of containers
- namespaces / Namespaces
- control groups (cgroups) / Control groups (cgroups)
- union filesystem (UnionFS) / Union filesystem (UnionFS)
- data, sharing / Sharing data between containers
- prune command, using / Pruning containers
- content trust / Content trust
- context-based routing / Context-based routing
- continuous integration (CI) / Demystifying declarative versus imperative
- control groups (cgroups) / Control groups (cgroups)
- control plane / Architecture
- copy-on-write technique / Copy-on-write
- custom images
- sharing / Sharing or shipping images
- shipping / Sharing or shipping images
- tagging / Tagging an image
- namespaces / Image namespaces
- official images / Official images
- pushing, to Docker Hub registries / Pushing images to a registry
D
- data volumes
- creating / Creating and mounting data volumes, Creating volumes
- mounting / Creating and mounting data volumes, Mounting a volume
- container layer, modifying / Modifying the container layer
- removing / Removing volumes
- declarative
- versus imperative / Demystifying declarative versus imperative
- about / Demystifying declarative versus imperative
- default logging driver
- defensive programming
- about / Defensive programming
- retries / Retries
- logging / Logging
- error handling / Error handling
- desired state
- reconciling / Reconciling the desired state
- development environment
- secrets, simulating / Simulating secrets in a development environment
- distributed application, executing
- logging / Logging
- tracing / Tracing
- monitoring / Monitoring
- application updates / Application updates
- distributed application architecture
- about / What is a distributed application architecture?
- terminology / Defining the terminology
- VM / Defining the terminology
- node / Defining the terminology
- cluster / Defining the terminology
- port / Defining the terminology
- service / Defining the terminology
- patterns / Patterns and best practices
- best practices / Patterns and best practices
- loosely coupled components / Loosely coupled components
- stateful component, versus stateless component / Stateful versus stateless
- stateless component, versus stateless component / Stateful versus stateless
- service discovery / Service discovery
- routing / Routing
- load balancing / Load balancing
- defensive programming / Defensive programming
- redundancy / Redundancy
- health checks / Health checks
- circuit breaker pattern / Circuit breaker pattern
- executing, in production / Running in production
- DNS service / Service discovery
- Docker
- for Mac / Docker for Mac and Docker for Windows
- for Windows / Docker for Mac and Docker for Windows
- installing, for Mac / Installing Docker for Mac
- installation link, for Mac / Installing Docker for Mac
- installing, for Windows / Installing Docker for Windows
- installation link, for Windows / Installing Docker for Windows
- architecture / Architecture
- system information, obtaining / Obtaining Docker system information
- system events, consuming / Consuming Docker system events
- Kubernetes, support for desktop / Kubernetes support in Docker for Desktop
- installing / Installing Docker
- docker-machine
- using, on Windows with Hyper-V / Using docker-machine on Windows with Hyper-V
- Docker CE
- about / Docker CE
- installation link / Installing Docker
- Docker Compose
- multi-service app, executing / Running a multi-service app
- service, scaling / Scaling a service
- application, building / Building and pushing an application
- application, pushing / Building and pushing an application
- Docker container
- versus Kubernetes pod networking / Comparing Docker container and Kubernetes pod networking
- Docker EE
- about / Docker EE
- deploying, on AWS / Deploying and using Docker EE on AWS
- using, on AWS / Deploying and using Docker EE on AWS
- infrastructure, provisioning / Provisioning the infrastructure
- Docker engine / The Moby project
- Dockerfiles
- using / Using Dockerfiles
- FROM keyword / The FROM keyword
- RUN keyword / The RUN keyword
- COPY keywords / The COPY and ADD keywords
- ADD keywords / The COPY and ADD keywords
- WORKDIR keyword / The WORKDIR keyword
- CMD keywords / The CMD and ENTRYPOINT keywords
- ENTRYPOINT keywords / The CMD and ENTRYPOINT keywords
- complex example / A complex Dockerfile
- image, building / Building an image
- multistep builds / Multistep builds
- best practices / Dockerfile best practices
- Docker Hub
- registries, reference links / Image namespaces
- Docker machine (DM) / Creating a Docker Swarm in the cloud
- Docker products / Docker products
- Docker Swarm
- about / Docker Swarm
- architecture / Architecture
- stacks / Stacks, services, and tasks, Stack
- services / Stacks, services, and tasks, Services
- tasks / Stacks, services, and tasks, Task
- creating / Creating a Docker Swarm
- single node swarm, creating / Creating a local single node swarm
- local swarm, creating in VirtualBox / Creating a local swarm in VirtualBox or Hyper-V
- local swarm, creating in Hyper-V / Creating a local swarm in VirtualBox or Hyper-V
- Play with Docker (PWD), using / Using Play with Docker (PWD) to generate a Swarm
- creating, in the cloud / Creating a Docker Swarm in the cloud
- application, deploying / Deploying a first application
- service, creating / Creating a service
- service, inspecting / Inspecting the service and its tasks
- tasks, inspecting / Inspecting the service and its tasks
- service logs / Logs of a service
- desired state, reconciling / Reconciling the desired state
- services, deleting / Deleting a service or a stack
- stacks, deleting / Deleting a service or a stack
- multi-service stack, deploying / Deploying a multi-service stack
- deploying / Deploying to Docker Swarm
- Docker Swarm routing mesh / The swarm routing mesh
- Docker Toolbox / Docker Toolbox
- Docker Trusted Registry (DTR) / Docker EE
- Docker UCP
- installing / Installing Docker UCP
- Domain Name System / Service discovery
E
- elastic compute cloud (EC2) / Deploying our application into AWS ECS
- Elastic Container Service (ECS)
- about / Overview of popular orchestrators, Deploying our application into AWS ECS, Introduction to ECS
- task, execution / Running a task in ECS
- Enterprise Edition (EE) / Docker products
- environment variables
- Kubernetes secrets, values / Secret values in environment variables
- exec form / The CMD and ENTRYPOINT keywords
F
- Fargate ECS cluster
- about / Introduction to ECS
- creating / Creating a Fargate ECS cluster of AWS
- filter / Inspecting containers
- followers / Swarm managers
- Fully Qualified Domain Name (FQDN) / Architecture
- Functions as a Service (FaaS) / The container ecosystem
G
- general availability (GA) / Kubernetes
- geo-awareness / Affinity and location awareness
- global services / Replicated and global services
- Google container / A short peek into Google’s container offerings
- Go template / Inspecting containers
- grants / Role-based access control (RBAC)
- Graylog Extended Log Format (GELF) / Logging drivers
- grep tool / Inspecting containers
- group ID (GID) / The COPY and ADD keywords
H
- health checks / Health checks
- Helm / Streamlining the deployment
- Homebrew
- about / Using a package manager
- installing, on Mac / Installing Homebrew on a Mac
- installation link / Installing Homebrew on a Mac
- host network / The host network
- host volumes
- using / Using host volumes
- Hyper-V
- docker-machine, using on Windows / Using docker-machine on Windows with Hyper-V
- local swarm, creating / Creating a local swarm in VirtualBox or Hyper-V
I
- image registries / Sharing or shipping images
- images
- volumes, defining / Defining volumes in images
- prune command, using / Pruning images
- imperative
- versus declarative / Demystifying declarative versus imperative
- about / Demystifying declarative versus imperative
- Infrastructure / Kubernetes master nodes
- Infrastructure as a Service (IaaS) / Docker CE
- introspection / Introspection
- IP address management (IPAM) / The bridge network
- IP Virtual Server (IPVS) / The swarm routing mesh
K
- kube-proxy / Cluster nodes
- kubeadm / Kubernetes support in Docker for Desktop
- kubectl
- testing / Testing Minikube and kubectl
- Kubernetes secrets, creating / Creating secrets with kubectl
- kubelet / Cluster nodes
- Kubernetes
- contexts, reference link / Testing Minikube and kubectl
- about / Kubernetes
- architecture / Architecture
- master nodes / Kubernetes master nodes
- supporting, for desktop in Docker / Kubernetes support in Docker for Desktop
- ReplicaSet / Kubernetes ReplicaSet
- deployment / Kubernetes deployment
- service / Kubernetes service
- versus SwarmKit / Comparing SwarmKit with Kubernetes
- Kubernetes pod networking
- versus Docker container / Comparing Docker container and Kubernetes pod networking
- Kubernetes secrets
- about / Kubernetes secrets
- defining / Manually defining secrets
- creating, with kubectl / Creating secrets with kubectl
- using, in pods / Using secrets in a pod
- values, in environment variables / Secret values in environment variables
L
- layered filesystem / The layered filesystem
- Linux command shell / The Linux command shell
- Linux security module (LSM) / Docker Swarm
- Load Balancer (LB) / Load balancing, The swarm routing mesh, Architecture
- load balancing / Load balancing, Load balancing
- logging drivers / Logging drivers
- loosely coupled components / Loosely coupled components
M
- Mac
- Homebrew, installing / Installing Homebrew on a Mac
- man-in-the-middle (MITM) attack / Why are containers important?, Content trust
- manager node / Replicated and global services, Swarm managers
- manual ECS cluster / Introduction to ECS
- Marathon / Apache Mesos and Marathon
- metadata / Inspecting containers
- Microsoft ACS / Microsoft ACS
- Microsoft Azure
- reference link / A short peek into Azure’s container offerings
- Minikube
- about / Minikube, Introduction to Minikube
- installing, on Mac / Installing Minikube on Mac and Windows
- installing, on Windows / Installing Minikube on Mac and Windows
- installation link / Installing Minikube on Mac and Windows
- testing / Testing Minikube and kubectl
- Moby project / The Moby project
- Multi-host networking / Multi-host networking
- multi-service app
- executing / Running a multi-service app
- mutual transport layer security (MTLS) / Secure communication and cryptographic node identity
N
- namespaces / Anatomy of containers, Namespaces
- network (net) / Container architecture
- Network Address Translation (NAT) / Architecture
- network firewalling / Network firewalling
- network namespace
- creating, in container execution / Running in an existing network namespace
- sharing / Sharing the network namespace
- networks
- prune command, using / Pruning networks
- about / The container network model
- null network / The null network
O
- Open Container Initiative (OCI) / Runc
- Open Container Project (OCP) / Runc
- orchestrator
- about / What are orchestrators and why do we need them?, Overview of popular orchestrators
- need for / What are orchestrators and why do we need them?
- tasks / The tasks of an orchestrator
- Kubernetes / Kubernetes
- Docker Swarm / Docker Swarm
- Apache Mesos / Apache Mesos and Marathon
- Marathon / Apache Mesos and Marathon
- Amazon ECS / Amazon ECS
- Microsoft ACS / Microsoft ACS
P
- package manager
- using / Using a package manager
- Homebrew, installing on Mac / Installing Homebrew on a Mac
- Chocolatey, installing on Windows / Installing Chocolatey on Windows
- Play with Docker (PWD)
- used, for generating Swarm / Using Play with Docker (PWD) to generate a Swarm
- reference link / Using Play with Docker (PWD) to generate a Swarm
- pods
- about / Pods
- network namespace, sharing / Sharing the network namespace
- life cycle / Pod life cycle
- specification / Pod specification
- and volumes / Pods and volumes
- port management / Port management
- PowerShell
- for Windows / PowerShell for Windows
- process ID (pid) / Container architecture
- prune command
- using, for resources / Pruning unused resources
- using, for containers / Pruning containers
- using, for images / Pruning images
- using, for volume / Pruning volumes
- using, for networks / Pruning networks
- using / Pruning everything
Q
- quotes container
- executing / Running a random quotes container
R
- Raft consensus protocol / Swarm managers
- read-only (ro) / Sharing data between containers
- redundancy / Redundancy
- ReplicaSet
- about / Kubernetes ReplicaSet
- specification / ReplicaSet specification
- self-healing / Self-healing
- replicated services / Replicated and global services
- resource consumption
- listing / Listing resource consumption
- reverse uptime / Reverse uptime
- Role-based access control (RBAC) / Role-based access control (RBAC)
- role-based access control (RBAC) / Docker EE
- rolling updates / Zero downtime deployments
- routing / Routing, Routing
S
- scaling / Scaling
- secrets / Secrets
- about / Secrets
- creating / Creating secrets
- using / Using a secret
- simulating, in development environment / Simulating secrets in a development environment
- and legacy applications / Secrets and legacy applications
- updating / Updating secrets
- security
- about / Security
- secure communication / Secure communication and cryptographic node identity
- cryptographic node identity / Secure communication and cryptographic node identity
- networks, securing / Secure networks and network policies
- network policies, securing / Secure networks and network policies
- Role-based access control (RBAC) / Role-based access control (RBAC)
- secrets / Secrets
- content trust / Content trust
- reverse uptime / Reverse uptime
- security group (SG) / Creating a Docker Swarm in the cloud, Deploying our application into AWS ECS
- self-healing / Self-healing
- service
- scaling / Scaling a service
- service discovery / Service discovery, Service discovery
- service level agreement (SLA) / Canary releases
- services, cluster nodes
- Kubelet / Cluster nodes
- container runtime / Cluster nodes
- kube-proxy / Cluster nodes
- services, Kubernetes
- API server / Kubernetes master nodes
- controller / Kubernetes master nodes
- scheduler / Kubernetes master nodes
- cluster store / Kubernetes master nodes
- shell form / The CMD and ENTRYPOINT keywords
- single node swarm
- creating / Creating a local single node swarm
- software defined network (SDN) / Secure networks and network policies, Comparing SwarmKit with Kubernetes
- solid-state drive (SSD) / Affinity and location awareness
- stateful component
- versus stateless component / Stateful versus stateless
- stateless component
- versus stateful component / Stateful versus stateless
- SwarmKit
- versus Kubernetes / Comparing SwarmKit with Kubernetes
- Swarm nodes
- about / Swarm nodes
- manager node / Swarm managers
- worker node / Swarm workers
T
- tag / Tagging an image
- tasks, orchestrator
- desired state, reconciling / Reconciling the desired state
- replicated services / Replicated and global services
- global services / Replicated and global services
- service discovery / Service discovery
- routing / Routing
- load balancing / Load balancing
- scaling / Scaling
- self-healing / Self-healing
- zero downtime deployment / Zero downtime deployments
- affinity awareness / Affinity and location awareness
- security / Security
- introspection / Introspection
- transport layer security (TLS) / Creating a Docker Swarm in the cloud, Secrets
U
- UCP cluster
- remote admin / Remote admin the UCP cluster
- Kubernetes, deploying / Deploying to Kubernetes
- underlay network / Architecture
- union filesystem (UnionFS) / Union filesystem (UnionFS)
- Universal Control Plane (UCP) / Docker EE, Deploying and using Docker EE on AWS
- universal unique identifier (UUID) / Defining the terminology
- user ID (UID) / The COPY and ADD keywords
V
- VirtualBox
- local swarm, creating / Creating a local swarm in VirtualBox or Hyper-V
- virtual ethernet (veth) / The bridge network
- Virtual Extensible LAN (VXLan) / The container network model
- virtual IP (VIP) / The swarm routing mesh
- virtual machine (VM) / What are containers?, Swarm nodes
- virtual private cloud (VPC) / Deploying our application into AWS ECS
- Visual Studio Code
- about / Choosing a code editor
- reference link / Choosing a code editor
- volumes
- defining, in images / Defining volumes in images
- prune command, using / Pruning volumes
- VXLAN Tunnel Endpoint (VTEP) / Multi-host networking
W
- Windows
- PowerShell / PowerShell for Windows
- Chocolatey, installing / Installing Chocolatey on Windows
- worker node / Replicated and global services, Swarm workers
- writable container layer / The writable container layer
Z
- zero downtime deployment
- about / Zero downtime deployments, Zero downtime deployment
- strategies / Popular deployment strategies
- rolling updates / Rolling updates
- health checks / Health checks
- rollback / Rollback
- blue-green deployments / Blue–green deployments
- canary releases / Canary releases
- zero downtime deployment, Kubernetes
- about / Zero downtime deployments
- rolling updates / Rolling updates
- blue-green deployment / Blue–green deployment