Docker Essentials for Python Developers

Explore essential docker components—runtime, command line, and compose—and compare docker desktop, toolbox, and engine bundles across Windows, macOS, and Linux, with orchestration tools like Kubernetes and Swarm.

Create a Docker ID on Docker Hub to store public container images, access the free tier, and download the Docker Desktop installers.

Install docker desktop on Windows 10 professional, enable linux containers for python development, verify the installation with docker version, and enable sharing of the C drive for container workloads.

Install and configure Docker Desktop on macOS, sign in to Docker Hub, adjust resources like ram and cpu, and verify the setup by running docker version in the terminal.

Install docker toolbox on Windows Home to run a Linux docker engine inside a VirtualBox VM. Note: legacy tool requires BIOS virtualization and uses the VM IP for port mappings.

Install and verify docker engine on Ubuntu, ensuring the daemon runs and the user can access the docker socket. Install docker compose via curl, set executable, and test running containers.

Install docker engine community edition and docker compose on CentOS seven, enable the stable repository, start docker with systemctl, and run without sudo while noting security risks.

Clone the repository from GitHub using git, in PowerShell or terminal, into your documents folder or another destination; access the three subfolders containing exercise files.

Learn to run Python in Docker containers and manage their lifecycle. Explore Flask, Django, Jupyter, and data science workflows with persistent volumes.

Explore how to set up a Python runtime environment in Docker by running containers with Flask and Django, using bind mounts, port mappings, and different Python versions.

Launch a Jupyter data science environment in Docker using the data science notebook image, enabling lab, including popular libraries, and mapping port 8888 with host directories mounted.

Launch and run TensorFlow, Jupyter, and TensorBoard in Docker containers to train a Keras classification model and explore PyTorch in a separate setup.

Create a production-grade flask rest API in a custom Docker container, building with a Dockerfile, installing requirements, and running with Gunicorn; expose port 5000 for the color boxes API.

Build and run a Django web server container by creating a Docker image from a Django project, configuring WSGI, collecting static files, and mounting a persistent volume for SQLite data.

Discover the basics of containers and Docker, learn what a container is, how Docker runs them across Linux, Windows, and Mac, and review container images, lifecycle, and updating apps.

Define a container as an isolated runtime with its own file system and network, preventing cross-application interference. Container images package a Python app with its dependencies for portable use.

Containers run isolated yet communicate through a virtual network bridge created by the docker engine, exposing unique IP addresses and optional host names for container-to-container, host, and external service communication.

Access applications running in containers through port mappings and host-to-container communication across tcp and udp. Explore container-to-container and host-to-container interactions, with dynamic IPs, service names, and DNS-based discovery for microservices.

Docker gives each container an isolated file system with binaries and libraries, while bind mounts and volumes let data persist beyond container removal.

Explore which applications suit containers, from web-based Python apps and Jupyter Notebook server to three-layer web services with Django, microservices, and scalable API patterns such as REST, gRPC, and queues.

Explore container runtimes, their engine and management tools, and how standards and orchestration enable deploying, monitoring, and scaling multi-container applications across development and production.

Explore development and production environments for container-based apps, covering image building, container runtimes, and ci/cd pipelines, plus orchestration tools like docker compose and kubernetes.

Discover container images as binary blobs with a file system and metadata that let containers run. See how base images, layers, and naming conventions shape image creation and use.

Explore Docker Hub, the largest container image registry, and learn about official Python images, common variants like regular, slim, and Alpine, plus use cases for development and production.

Create self-contained custom container images for Python apps using Docker build and Dockerfile, speeding deployment, automating pipelines, and simplifying multi-instance microservice start-ups.

Learn how docker builds images from a Dockerfile, creates containers with a file system and metadata, and runs them via startup command, and pushes images to a registry for production.

Explore the image and container lifecycles in Docker: build, tag, and push images immutably to a registry, then create, run, pause, stop, or kill containers.

Master the immutable containers principle for production deployments with Kubernetes, and learn how rolling updates replace containers via new images rather than in-place changes.

Learn to run and manage interactive docker containers for python development, including port and volume mappings, background mode, image management, and Portainer, with practical command-line exercises.

Master the docker command line interface, subcommands, and common options, learn how docker run and abbreviations streamline tasks, and explore docker machine, compose, and remote docker engine concepts.

Run interactive containers with docker run -it to allocate a virtual terminal and attach streams. Detach and reattach with ctrl-p ctrl-q and docker attach, using nano for text editing.

Publish and map container ports with Docker run -P or --publish, exposing container ports on the host, monitor mappings with Docker port, and edit URLs to access the service.

Declare bind mounts to map host folders into a container at creation, supporting multiple mounts with dash V or dash mount, and enforce read-only options and absolute paths.

Display containers with docker container ls or docker ps, use -a for all, and note id, image, command, created, status, ports, names, and host port 9999 to container 8888 mappings.

Learn to reference docker containers by id or name, set custom names with --name, rename containers, and use the docker name generator that creates two-word underscore names.

Start containers in background (detached mode) using docker run and verify with docker ps and port mappings; run a flask-based microservice and ensure startup command can operate without standard input.

Learn how Docker captures container logs from standard output and standard error, viewable with Docker logs, and stream in real time with -F and timestamps with -t.

Attach to a container running in background with docker attach to view real-time stdout and stderr for interactive and non-interactive containers, and use docker logs for earlier output.

Learn how to use Docker exec to run ad hoc commands in a running container for development tasks, including initializing Django databases and creating a superuser.

Stop a running docker container by issuing docker stop, which sends sigterm after a grace period and may be followed by sigkill via docker kill for immediate termination.

Create a container without starting it using Docker create in detached mode, which can be interactive with -it, and start it later with Docker start.

Start a stopped or created Docker container with docker container start to run its main process; it starts in background by default, use -a and -i to attach, and watch for port conflicts.

Learn how the docker inspect command reveals detailed container metadata in json, including state, config, environment variables, startup command, image name, working directory, volumes, port mappings, and networks.

Pull images from a registry to update versions in the local image cache and speed up container launches, while learning tagging, latest defaults, and image naming.

Learn how to rename docker images by adding new names with docker image tag or docker tag, enabling shorter names or registry-specific identifiers; remove unused names with docker rmi.

List Docker images and manage them with Docker image ls, Docker rmi, and Docker image prune to remove unnamed, untagged, or unused images from the local image cache.

Inspect image metadata with docker inspect to view config, env vars, entrypoint and cmd for startup, plus working directory and /data volumes; docker history reveals steps from newest to oldest.

Use docker run and docker create to start containers with a startup command derived from image metadata, and optionally override entrypoint or cmd using bash for migrations.

Set and override linux environment variables in docker containers with the docker run -e flag and env files, and pass host variables when available.

Delete docker containers by name or id, and use -f to force deletion of a running container. Prune removes all stopped containers, permanently deleting their file systems.

Discover Portainer, a free, containerized gui for Docker; deploy and manage containers and images via a web dashboard at localhost:9000, with logs, inspect, stats, and Docker exec access.

Learn to build and publish Python container images by manually creating and committing containers, including a Jupyter notebook image, then automate with a Dockerfile and docker build for Docker Hub.

Explore how container images combine a file system archive and metadata, and how to build them from a base image using manual steps or a Dockerfile.

The lecture demonstrates a manual image build process with two exercises: a Jupyter notebook image with PyTorch and torch vision, and a Flask microservice image with metadata changes.

Learn how Dockerfile format guides automated container image creation with the docker build command, including base image selection, instructions like from, copy, run, and metadata.

Build and run a stateful Flask REST API microservice for managing colored boxes which can hold an arbitrary number of balls using SQLAlchemy, Docker, and an automated image build process.

Master the docker build command to generate container images from a Dockerfile, manage build context with .dockerignore, and use dash t and dash f options to name and select image.

Learn how the from and arg instructions define and reference the base image, enabling parameterized dockerfiles and build-time overrides for CI/CD ready images.

Master how the copy instruction moves files from the build context to the image filesystem, handling source and destination paths, trailing slashes, and directory contents, with ownership and permissions considerations.

Explore how the run instruction executes shell commands inside a temporary container, requiring basic Linux command line skills and a linear, non-background Docker build process.

Explore Dockerfile volume instructions, mount points, and the lifecycle of volumes, showing how volumes ensure data persistence and initialization, with bind mounts and unnamed volumes explained.

Set up Docker start-up with Entrypoint and CMD to define default executable and parameters, override them at runtime, and compare exec form versus shell form for efficient production.

Final dockerfile demonstrates packaging a color boxes microservice for production using build arguments, gunicorn, and a persistent SQLite database on a mounted volume.

Push your image to Docker Hub by logging in and tagging it with your Docker Hub namespace, then upload with docker push to a public repository on the free tier.

Learn to push images to registries beyond Docker Hub, including private registries and Google Cloud Container Registry, with proper tagging, registry URLs like gcr.io, project IDs, and authentication.

Explore docker compose for multi-container development and test environments, deploying networks, volumes, and services through practical examples like TensorFlow with Jupyter and TensorBoard, and MariaDB with Nginx and PostgreSQL.

Explore how Docker Compose orchestrates multi-container deployments with services, networks, and volumes, using a declarative YAML model to declare the desired state and enable service discovery.

Describe how to build a Docker Compose file using version 3.7, with services, volumes, and networks, and manage environment, ports, and indentation rules.

Explore docker compose command reference to deploy multi-container applications, manage up and down with foreground or detached modes, view logs, handle multiple compose files, and manage service dependencies.

Orchestrate a deep learning workspace with docker compose by running two containers—Jupyter Notebook server with TensorFlow and Tensorboard—sharing notebooks and logs via bind mounts for reproducible experiments.

Deploy a docker compose setup with a flask-based microservice with a restful api using sql alchemy to an external mariadb over a virtual network, plus a database monitoring tool container.

Explore a dockerized Django web site deployment using WSGI, PostgreSQL, and Nginx as a frontend proxy and load balancer, with development and production-like architecture.