Deploy and Run Apps with Docker, Kubernetes, Helm, Rancher

Explore how Docker uses Linux containers to run and manage applications quickly without a guest operating system, enabling seconds-to-start containers and easy deployment.

Install Docker for Mac, sign in to Docker Hub, and enable Kubernetes on Docker Desktop; verify the installation with docker version and kubectl, and manage images and containers.

Install Docker Desktop for Windows professional or enterprise, sign in to Docker Hub to access Docker images, run Linux containers by default, and enable a one-node Kubernetes cluster for verification.

Learn to install Docker and Kubernetes on Linux using snap, including setting up an AWS Linux instance and configuring MicroK8s for a working Kubernetes environment.

Map a host port to the container’s internal port 80 to expose a web app like nginx, enabling browser access from your laptop using the mapped host port.

Learn to access a running engine X container with docker container exec, run an interactive bash, and inspect volume mappings exposing local files inside the container.

Learn how to configure containers with environment variables, start a small busybox container with docker run, inspect and pass variables, and verify that apps inside can access them.

List running containers with docker container ls to view IDs, image, and port mappings; use the IDs to stop or remove containers.

Stop running containers with Docker container stop, whether one or multiple, and understand that stopping may take up to ten seconds as a stop signal is sent.

List stopped Docker containers and learn to stop one or multiple. Use docker container ls -a to view them and docker stop to stop them, noting when they exited.

Remove stopped docker containers to free space, noting that data inside unmounted containers is lost unless volumes are mapped; use container ids to remove one or multiple containers.

Docker images are built from a doc file using a from command, creating layers in a union file system, with read-only layers reused by containers and a writable layer.

Explore a six-container microservice architecture deployed with nginx proxy for a production setup, including a to-do app, Redis cache, Elasticsearch search, with scaling, failover, and ingress considerations.

Create your own GitHub repository for the to-do source code, detach from the instructor’s project, and initialize, commit an initial commit, and push the local repository.

Learn to create a docker network with the bridge driver and attach containers to it now, ensuring cross-container communication for the app solution as you containerize components.

Pull the official Redis image from Docker Hub and run a fixed version in a container, attach it to a named network, and expose port 6379 for local access.

Learn to start app backend by wiring containers for Postgres, Redis, Elasticsearch, bootstrapping API with npm start, and using REST API to manage and search to-dos via cache, DB, index.

Configure the api backend to read environment properties from the host when running in containers with docker network, swapping local props for environment variables.

Create a development dockerfile for the Angular app client, enabling in-container development with webpack and npm, while excluding node_modules with dockerignore and exposing port 4200.

Configure a custom nginx proxy for to-do app with upstreams for the core client and API server, mapping / to the client and /api to the API via a Dockerfile.

Save all created docs, service code, and configuration changes, then commit and push them to GitHub to kick off a completely containerized solution.

Start the to-do api container with proper environment variables, port mapping, and anonymous volumes, and connect it to Postgres, Redis, and Elasticsearch services for a running backend.

Test and iterate changes in a containerized app by mapping source code into the running container, watching recompilation, and validating live API calls with Docker, Kubernetes, Helm, and Rancher workflows.

Explore managing multi-container apps with Docker Compose, defining services, networks, volumes, and environment variables in one file, then bring up or down with docker-compose up and down.

Write a docker-compose.yml to orchestrate all app containers, specifying services, images, ports, and environment variables, while configuring volumes, dependencies, and a shared network for seamless communication.

Practice starting and testing a multi-service app with Docker Compose, observe service logs, and learn to make code resilient to container startup order by delaying actions until connections are established.

Create a custom postgres scripts image that initializes a todo db from a secret sql script, using environment variables for user and password, wired in docker compose.

Create a backend start script that waits for Elasticsearch to be ready before starting the API, by overriding npm start with a docker-compose run script that polls ES.

Force the build to refresh API, view, and postgres containers, then start up the services, create the database and table, and verify elastic search connectivity.

Experiment stopping services with Docker Compose to test resilience, showing Redis, API, and client crashes and the need to decouple caching, storage, and search for reliability.

Contrast stateless and stateful containers by noting databases and caches are stateful while rest api is stateless. Explain how stateless containers scale easily and suit development and ci, while production typically keeps a PostgreSQL cluster and an ElasticSearch cluster outside containers.

Learn how the docker compose file defines the desired state and how compose up reconciles it with the actual state, including managing replicas within the cluster.

Access containers and execute commands using docker compose and docker compose exec. Explore running shell sessions, reading files, and inspecting the app directory to understand the API server code.

Explore why Docker Compose falls short for production, and learn how clusters, orchestration, service discovery, secret management, load balancing, and monitoring with Kubernetes and Rancher enable scalable deployments.

Reframes the system into microservices by separating cache, storage, and search behind an API gateway, uses RabbitMQ for ingestion, and enables independent, scalable releases and cross-language deployments (Go and Java).

Walk through a docker compose file that shows how RabbitMQ, cache, ingestion, search, and storage services start and connect via service names with externalized environment variables, coordinating the API gateway.

Explore docker compose networks and service-name routing for inter-service communication. Understand internal ports versus external mappings so the API gateway can reach cache and store services.

Decouple, scale, and enable asynchronous messaging between services to improve resilience, build production grade Docker images, publish to Docker Hub, and navigate Docker registries for cloud deployments.

Explains creating a production Dockerfile for an Angular app using a two-stage build: build with Node to generate dist, then serve with Nginx on Alpine, with proper config and permissions.

Create a production docker compose file that uses production images, overrides dev settings, and pushes images to Docker Hub; deploy the production stack and verify via configured ports.

Learn to build and run production images with Docker Compose by layering a prod override on the base file, configure the proxy and ports, and push images to Docker Hub.

Save the project by preserving all changes and production docker images, pushing them to Dr. Hobbs, and prepare to begin the next section on continuous integration.

Learn to configure Travis CI with GitHub to automate builds and tests, and push Docker images to Docker Hub. Deploy to production using containers and Elastic Beanstalk for rapid delivery.

Set up a Travis CI account, link it to a GitHub repository, and configure settings and webhooks to trigger automated builds for every commit.

Commit changes to trigger a Travis CI build, run tests inside a Docker container with Chrome headless, and push images to Docker Hub, updating the readme with build status.