Practical Cloud Native - Docker and Docker Compose

Set up a simple web app, create and save source code, and run it locally with a web server and Lifesaver extension; future lessons containerize it with Docker.

Containerize any application by creating a container image from the source code with Docker build, then spin up a container from that image.

Containerize a static website by creating a Dockerfile, selecting a base image from Docker Hub, copying code, building the image, and running a container with port 80 mapped to localhost:1770.

after containerisation, update the readme with build and run steps for the team, then build, run, and verify the app by navigating to localhost on the specified port.

Learn how to destroy a container, remove it with docker rm, and observe the application status after removal.

Learn how to run a container in the background by using the option that starts it in background on demand, freeing the terminal for other commands.

Discover how to list running containers, inspect container names and exposed ports, and manage multiple containers created from the same image.

Learn how to show the logs of a container using docker logs, inspect containers by name or id, and stream real-time logs with the -f option.

Log into the container to obtain an interactive shell, explore the file system, and edit files to practice debugging and troubleshooting, while noting container mutability is not recommended.

Map multiple host ports to the container’s port 80 to expose the same application. Access it from the host via localhost on mapped ports, illustrating docker port mappings.

Mount host folders as volumes to Docker containers to share data, enable persistence, and access files inside the container using the Docker run command and absolute paths.

Attach environment variables to a Docker container at runtime using the -e option, verify with in-container env, and note that changes are ephemeral across restarts.

Review how to operate containers, create and run your application inside a container, and use commands to list containers, view logs, attach an interactive shell, and manage ports and volumes.

Docker Compose provides a declarative alternative to the imperative approach, defining services, images, ports, volumes, and environment variables in a YAML file, then using compose up.

Migrate from docker run to docker compose by creating a docker-compose.yml with version 3.9 and translating the container into a compose service with image, ports, and environment variables.

Explore docker compose basics: build an image from a context, specify the output image, and run containers with compose, highlighting two build steps.

Practice replacing docker build with docker compose to build images using a specified context, then run services locally and observe container naming and compose conventions.

After migrating to Docker Compose, update your team documentation to streamline workflows and reduce reliance on long commands. Push your code and add documentation to align enterprise level work.

Master YAML basics, including key-value pairs, nested objects, lists, multiline strings, and comments, and convert between YAML and JSON.

Explore how Docker Compose orchestrates multiple containers and defines mini containers in an example, illustrating container setup and orchestration.

This hands-on session demonstrates defining a multi-container docker compose setup by adding an API container beside the frontend, configuring ports and environment variables, and testing at localhost:1990.

Access APIs inside the container network using service names as hosts and internal ports, enabling internal communication without exposing them, and let the API reach the database by name.

Apply the multi container strategy to connect the front end with the API on exposed ports, and diagnose a cross-origin issue blocking fetch calls.

Use the ambassador container as a gateway to fix cors without changing the api. It intercepts requests to 1990 and rewrites them to 1991 with headers that enable cross-origin calls.

Fix cors with an ambassador container by routing through Nginx, overriding default config via a mounted file, and proxying to the API on port 88.

Learn to call an API from the frontend using JavaScript, handle the response, map data into a dynamic list, and render it on a new page.

Learn how a router container unifies frontend and backend origins by routing and rewriting requests based on path, using localhost:1000 as the unified origin.

Implement the router container in a hands-on docker compose session and customize its routing to forward API and frontend traffic. Expose only the router, then test by visiting localhost.

This recap highlights the project: the frontend calls a ready API to fetch data, fixes cost origin issues by container, and implements an outer container to unify origin and host.

Explore containerisation by building a lightweight, single-file web application that runs a web server, exposes an endpoint, and renders a hello page.

Learn to set up a Go project in a local directory, edit with visual studio code, and run the app without containers on localhost, before moving to containerization.

Containerize a Go application with a dockerfile based on Alpine, copy source, set a startup command, build with docker compose, and expose a port.

Update the README to reflect the containerised application and get started using docker compose. Start the application with docker compose and follow this good practice to stay up to date.

Learn how CMD and ENTRYPOINT define a container's startup command, with ENTRYPOINT specifying the executable and CMD providing default arguments. The lecture shows how they interact to control container startup.

Learn to set up a comfortable local dev environment with Docker Compose, enabling hot reload by mounting host code as a volume, avoiding rebuilds and speeding iteration.

Master multistage builds to optimize production release images by compiling to a binary artifact and copying it into the image. Start the app from the binary rather than source code.

Build a production-ready image using a multi-stage docker build, creating a small binary artifact and copying it into an alpine runtime to minimize container size.

Discover how to containerize a Java web app with docker, using the Earth Service open-source project with a simple reading endpoint and a focus on dependency management and optimized builds.

Clone the Java source code, choose a Maven builder image, copy the code, run Maven package, and produce a runtime image with the built artifact.

Learn to containerize a Java runtime with Docker Compose by building an application service, selecting a Java base image, configuring the entrypoint, and exposing the container port for testing.

Learn how package managers manage dependencies and cache downloaded modules to speed up builds, whether locally or inside containers, by caching in local and remote repositories.

Learn to enable docker buildkit, use caching and security features, and configure manifest options to optimize builds; mount a cache directory to persist dependencies for subsequent builds.

Master buildkit by mounting a cache folder for Docker builds, reusing cache across runs, and invalidating it with a new file while enabling export settings and observing initial image downloads.

Adopt a practical strategy to containerize any app by identifying prerequisites, base images, and the language or framework via documentation or reverse engineering, then define build steps and entry points.

Explore packages and commands by opening an interactive shell in the base image to discover repositories, test commands, and reverse engineer setups before writing a Dockerfile.

This hands-on lecture shows building an alpine-based image, locating and installing the vault command line interface via the package manager, updating and searching packages, and removing the container after exit.

Learn how Docker images consist of stacked layers stored in a registry, how pulling downloads layers, how modifying a layer invalidates later layers, and how caching optimizes builds.

Install and run the SCoPI tool to inspect a Docker image, view and extract its layers from the OCI format manifest, and examine files added in the final layer.

Build a Docker image from scratch to demonstrate layer caching, cache invalidation, and how changes affect subsequent layers and manifests.

Combine consecutive run commands into a single layer to optimize Docker images; update dependencies and remove temporary files within the same layer to avoid wasted space.

Optimize docker images by combining consecutive run commands, generate a 24 megabyte test file, copy and remove it, and compare image sizes before and after optimization.

Start with the least changed layer to optimize Docker builds. Copy the dependency manifest and install dependencies before the rest of the code, applying this across languages.

Explore how dockerfile layering affects build and push performance. Learn to optimize by reordering instructions, installing dependencies early, and combining consecutive steps to reduce layers.

Explain a layer-optimized, multi-stage dockerfile workflow: start from a base image, copy package manifests, install dependencies, copy source, build, then create a final image with an entrypoint.

Apply the Maven Dockerfile format to a Java project by layering an image, installing dependencies (offline when possible), copying the manifest, and packaging with a Java command.

Start with a minimal, less changed layer using buildkit, install dependencies offline with caching, mount source code, build only needed components, and validate the app running on localhost.