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.

Start containers with docker run, using a chosen image, optionally naming the container, running in detached mode, mapping ports, and using volumes to persist data.

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.

Map local files into a Docker container with volumes to serve pages from an engine x web server on port 88, then start, stop, and inspect containers.

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.

Explore docker networks for multiple containers, moving from the default bridge to custom networks with dns automatic network discovery, container hostnames, and reduced need for port mappings.

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.

Containerize the three search, database, and cache services plus a proxy to ship independent images, ensure container networking with upstream servers, and prepare docker compose files for six interconnected containers.

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

Rebuild the app backend docker image with code updates, overwriting the same tag as you iterate, and use continuous integration and deployment to speed builds with cached layers and context.

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.

Change the Angular app client to use a separate proxy, switch from web pac to pac, expose localhost ports inside the container, and disable host shake true for proxy access.

Build an angular client docker image, tag it, overwrite the previous image, and prepare a proxy image using engine X.

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.

Build and tag a custom nginx proxy docker image to route /api requests to the rest server, using a prepared dockerfile and configuration.

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.

Start the app client (Angular) container by mapping local source code into the container and mounting node_modules. Run four containers, expose port 4200 behind a proxy for browser access.

Start the nginx proxy container to expose your custom client and rest api server, publish port 88, and test the end-to-end container deployment on the network.

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.

Stop all running containers, remove stopped containers, and clean up volumes to persist data before the next section on starting organized containers.

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.

Update the API backend source code to improve docker compose startup, use per-request Postgres connections, add index existence checks, and wait for elastic to be ready before serving reads.

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.

Update docker compose to build api images, specify build context and image names, and override the start command with a script that checks elastic before running the api server.

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.

Save all code changes and prepare for the discussion of stateful and stateless services, using named volumes to pass data outside containers and push the app image.

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.

Explore how health checks determine when a container is alive and ready to serve traffic, and compare Docker Compose practices with Kubernetes readiness and liveliness probes.

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).

Clone the to-do cloud start source code from GitHub to explore its microservice architecture, Docker Compose setup, multi-container environment, and a new message broker that enhances resilience and scalability.

Create your own GitHub repository for the cloud project, keep it private or make it public, then copy the commands and push the local source code to the remote.

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.

Start the app solution by pruning volumes, building Docker images, and launching containers with Docker Compose, then test the API gateway, queues, and memory cache flow.

Explore how to scale a cache ingestion with docker-compose, using unique container names, and implement round-robin distribution across multiple containers.

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.

Build production-grade Docker images and push them to registries via CI pipelines. Explore using Docker Hub for public images and Quay.io for private enterprise artifacts.

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.

Push all built production images to Docker Hub by building with Docker Compose, tagging and logging in, then pushing; this prepares for automation and introduces continuous integration.

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.

Enable Travis CI for your GitHub project with a .travis.yml that builds docker images, runs chrome headless tests, and pushes to Docker Hub via Travis environment variables.

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.