Python in Containers

Explore how to install and configure Docker across Linux, Windows, and macOS to build and run Linux containers for Python, including Docker tools, orchestration options, and Docker Hub images.

Create a Docker ID to use Docker Hub for storing images and pulling them to any container runtime, and learn to sign up, verify email, and log in.

Explore docker basics hands-on via play with docker labs; learn to create a multi-node environment, run a flask app in a docker container, build image simple-flask:v1.0.5, and expose port 5000.

Install docker on ubuntu using get-docker.sh to set up docker community edition with cli, containerd, and docker compose. Use docker machine with virtualbox and minikube for single-node kubernetes.

Install Docker on CentOS 7, including Docker CE, cli, and containerd runtime, Docker Compose, Docker Machine with VirtualBox, and Minikube; run a Python container and note security implications for production.

Explore security implications of running Docker on Linux, including root access via the Docker daemon and socket, group permissions, and the need for isolated Docker Machine environments in shared environments.

Install Docker Desktop on Windows 10 Pro, enable virtualization and Hyper-V to run Linux containers, and explore Docker Desktop settings for Kubernetes, shared drives, and Docker Hub login.

Switch to Windows containers in Docker Desktop for Windows to run Python using the windowsservercore image with PowerShell; gui apps aren't supported, cli-only workflow.

Learn how Docker Desktop for macOS runs Linux containers with HyperKit and MobyLinuxVM and enables Kubernetes, while providing Engine, Compose, Notary, and Credentials Helper.

Install and configure a Docker environment on Windows Home using Docker Toolbox and Minikube, run Docker engine in VirtualBox, and deploy Python container accessible at Minikube IP:5000.

Master container lifecycles with Docker run, Docker pull, and Docker rm by using the Python image from Docker Hub to create and interact with containers on the command line.

Explore integrating python containers with a host by using docker cp, volumes and bind mounts for code, and expose applications through port mappings for seamless development.

Explore how a container image functions as a filesystem plus metadata, including layers, entrypoint and cmd definitions, environment variables, and how Docker inspect reveals image details like digest and id.

Explore advanced docker container management, including interactive and detached modes, docker logs, and resource controls with memory, cpu limits, stats, and container lifecycle commands.

Learn to run and connect multiple containers through a virtual network, using container names for DNS name resolution and inter-container communication. See practical setups with Postgres, PgAdmin, and Django apps.

Explore docker networking by examining the bridge network, NAT behavior, private IPs (172.17.0.0/16), and how containers communicate with each other, the host, and the internet.

Discover how ephemeral container filesystems disappear after restart, and achieve data persistence with volumes and bind mounts. Learn to create, mount, and inspect volumes and host directories for lasting data.

Learn to build container images with a Dockerfile, including base image, copy and run steps, environment variables, and exposing ports for a Flask app.

Ship container images to Docker Hub by logging in, tagging, and pushing, while exploring repositories, tags, private vs public plans, collaborators, official images, and vulnerability scanning insights.

Explore how Python base images vary by tag and base, from python:latest to Debian, slim, and Alpine variants. Learn to select and pull the right image for containerized Python.

Explore Kitematic, a standalone Docker GUI, to manage containers and images with a graphical interface, including creating containers, viewing logs, and configuring ports, volumes, and networks.

Portainer provides a web-based Docker management GUI that runs as a container and connects to local or remote runtimes, enabling standalone deployment and containers, images, networks, and volumes management.

Docker Machine creates and manages Docker runtime environments in virtual machines, local or cloud, using a driver model and support for existing Linux via ssh.

Create and manage docker-machine instances with the VirtualBox driver, configure environment variables, map ports, and use boot2docker for a portable docker runtime.

Compare docker machine with Hyper-V and VirtualBox on Windows Pro. Create an external switch, boot with boot2docker.iso, and map ports to the machine IP.

Create a repeatable Docker runtime on AWS with Docker Machine and the amazonec2 driver, manage credentials and security groups, and open ports for container access.

Create and manage docker machines on Google Cloud Engine, configure credentials via gcloud or credentials.json, and open ports with firewall rules to run python in containers.

Build a python container image manually by creating a Linux filesystem with Python libraries and source code, running a Flask app, and committing the image with docker commit.

Automate Python image builds with a Dockerfile and context, using from, workdir, copy, run, env, and cmd to install libraries, set startup commands, and test production-ready images.

Master the from command and Dockerfile basics like workdir, copy, env, run, and cmd. Explore multi-stage builds, base images, and digest references from Docker Hub or private registries.

Discover how dockerfile commands manage image content with WORKDIR to set the working directory, COPY to transfer files from the build context, and ADD for tar archives and remote URLs.

Explore the RUN command in Dockerfiles, its shell and JSON array forms, how it runs in intermediate containers, and how environment variables, PATH, and caching influence image builds and layering.

Modify image metadata with ENV, USER, and LABEL in Dockerfiles, manage environment variables and PATH, and run commands as different users, with runtime overrides via --env.

Explore how Dockerfile volume declarations create mount points like /data, /web, and /static to enable data persistence and binding with runtime port mappings via expose.

Master how ENTRYPOINT and CMD define a container's start-up command, how the exec and shell forms operate, and how overrides with docker run and signals shape behavior.

Explore parameterizing dockerfiles with arg and build-arg. Convert build-time args to envs for runtime configuration and label images to track base image and library variants.

Learn to build reusable container images and configure them with environment variables, configuration files, and command line options. Explore dockerfile parametrization and base-image reuse with json and ini configs.

Learn build time vs run time execution for Python apps in containers, exploring initialization strategies, migrations, admin user creation, and runtime vs build time configuration using dockerfiles and startup scripts.

Explore techniques to shrink python docker images without changing functionality by comparing standard, slim, and alpine base images and their impact on size and performance.

Utilize a multistage build with dev and prod stages to produce fast, small docker images by compiling Python code with Cython and transferring a compiled library between stages.

Learn how to build custom Python images for dev and prod stages, using multi-stage dockerfiles to preinstall Cython and Flask components, shortening build time while preserving performance.

Build base images from scratch with explicit software versions and trusted components for secure development. Create Python development and production images for Flask apps using dockerfile strategies and rootfs workflows.

Master testing and debugging Python apps in containers by applying static tests with PyLint and unit tests with PyTest, then explore production image testing and debugging with PDB.

Containerize a Django development workflow by using a base image and Dockerfile, initialize project and applications, migrate sqlite3, and run the development server locally.

Examine Django's runtime architecture and containerization for production, pairing Python, databases, application servers, and proxy layers to deliver scalable, highly available deployments across public or private clouds.

Learn production deployment of Django and Flask using Gunicorn, uWSGI, or mod_wsgi; decouple app and web servers with nginx or apache, and build Docker images for scalable workflows.

Learn to deploy production-grade databases with PostgreSQL in a Django app, including containerized setup, user and database initialization, environment-driven config, and persistent volumes for data integrity.

deploy a production-grade MariaDB database for the Django Pulse app by building a MariaDB container, configuring environment variables, performing migrations, and using a universal image with DJ database URL.

Deploy the Django Pulse app behind an nginx proxy to serve static files, terminate https, and load balance across multiple app servers.

Explore automating multi-container Python applications—from building and wiring images, networks, and volumes to deploying with Docker Compose, Swarm, and Kubernetes—through scripted, repeatable workflows.

Ship container images efficiently by exporting, importing, saving, and loading tar archives, or using image registries like Docker Hub with push and pull for automated deployment.

Explore how image registries and repositories organize Docker images, including standard naming, tags, and digests, and learn how to pull and push images to Docker Hub, private, or local registries.

Explore local registry technologies for container images, including Docker Registry, Harbor, and JFrog Artifactory, with caching and pass-through proxies, and compare benefits for small teams vs DevOps.

Integrate GitHub with Docker Hub to automate image builds, webhooks, and deployment pipelines from source push to production in a cloud and local environment.

Explore how GitLab enables containerized Python projects with a multi-stage docker build, pytest tests, and image security scanning, all through a single ci/cd pipeline and integrated image registry.

Learn to scan container images for known vulnerabilities using CVE data, inspect image layers and tags, and use Claire to generate reports and guide fixes.

Deploy production containerized Python applications using Docker by mastering multi container deployments with Docker Compose and Swarm, and compare Docker’s development focus with Kubernetes’ operations focus.

Learn how docker compose simplifies deploying multi-container apps by wiring services, networks, and volumes, and how to bring up and down the app with initialization steps.

Learn how to declare version and volumes in a Docker Compose file using yaml, focusing on version 3.7, networks and external volumes, and sharing volumes across services.

Explore docker compose networks by declaring networks and attaching services to them, enabling DNS discovery, internet access, and traffic segmentation across deployments.

Explore how Docker Compose defines services as containers, maps images and networks, and uses volumes, environment variables, depends_on, and port mappings to orchestrate deployments.

Master docker compose for multi-container deployments, using registry-backed images, build options, and parallel builds to accelerate production, testing, and ci pipelines.

Learn how Docker Compose shifts from imperative deployment to a declarative model, manage a three-service Django app (db, app, proxy), upgrade Postgres, and initialize migrations with the run subcommand.

Docker compose uses a declarative approach to describe the desired state and upgrades Postgres from 11.3 to 11.4, preserving data via volumes.

Discover Docker Swarm fundamentals for multi-host deployments, including manager and worker nodes, overlay networks, swarm services, global and replicated deployments, port publishing, and data replication for resilience.

Learn how to run standalone containers within a Docker Swarm, using overlay networks for cross-node communication, and understand image handling, publishing ports, and limitations on persistent volumes.

Deploy swarm services to manage containers across a cluster, defining replicas, placement, health checks, and update policies, while handling service endpoints and round-robin traffic.

Explore swarm services, replicas, and tasks, and learn how endpoint VIP and ingress routing distribute traffic across replicated and global services, including host mode publishing.

Learn how to deploy multi-container Python apps on a Swarm using Docker Stack and compose files, manage networks, configs, and secrets, and scale services with replicas.

Deploy a docker swarm stack for Django Pulse with Galera MariaDB cluster and Nginx proxy, enabling high availability, synchronous master-master replication, and automatic failover across multiple nodes.

Navigate Docker Swarm as a programmatic platform for running microservice components as containerized services. Discover how services, tasks, replicas, deployment modes, placement constraints, networks, and service endpoints enable scalable architectures.

Explore how Docker Swarm uses volumes for persistent data, and how health checks, configs, secrets, and global deployment patterns create resilient, initialized services.

Explore docker swarm lifecycle by updating stacks, deploying new service versions, and rolling back when needed, while configuring parallelism, delay, and monitor settings, and enforcing CPU and memory reservations.

Docker enables container image creation and registry delivery to ship Python applications from development to production, using runtime and orchestration tools, compose for deployments, and swarm stacks for scalable clusters.

Explore how Kubernetes orchestrates containerized Python applications, compare it with docker swarm, and deploy from a single-node mini cube to a multi-node cluster on Google Cloud.

Explore how Kubernetes orchestrates containers with master and worker nodes, deployments, pods, services, namespaces, and storage to enable scalable, isolated workloads across clusters.

Install a development Kubernetes cluster with Minikube to mirror production features, including dashboard, dynamic storage, Nginx ingress, and optional EFK logging.

Launch a minikube dashboard, deploy a Flask app with kubectl run, then expose it via a replica set, service, and ingress using yaml configurations.

Deploy a multi-container Django Pulse app on minikube, wiring components with postgres, nginx, and services through an ingress while using DNS, replica sets, and secrets for stable microservice communication.

Explore deploying Django Pulse on a Kubernetes cluster with replica sets, services, ingress, and Postgres, using persistent volumes and PVCs for dynamic provisioning in Minikube.

Learn how Kubernetes pods rely on replica sets to maintain a desired number of pods using selectors and templates. Discover why deployments enable rolling updates.

Explore deployment controllers in Kubernetes, showing how rolling updates replace replica sets with new pod templates, controlled by max surge and max unavailable, with readiness and liveness probes.

Explore StatefulSet and DaemonSet controllers, enabling ordered pod startup with fixed names and per-node deployment. Learn how StatefulSet provides predictable names and volumes, while DaemonSet covers one pod per node.

Explore Kubernetes job and cronjob controllers, using a config map to initialize a Django app database, run migrations, and perform scheduled backups, with backoff and logging practices.

Learn how Kubernetes services provide stable interfaces to dynamic pods by using cluster IPs, DNS, and label selectors, including nodeport, headless, external name, and load balancer types.

Explore Kubernetes volumes, including emptyDir, hostPath, and persistent volumes, and learn how PVCs, storage classes, and access modes enable dynamic provisioning and data persistence.

Deploy a multi-container Django app to Google Kubernetes Engine, configure Nginx ingress, and connect to Google Cloud SQL for Postgres with declarative YAML, init jobs, and automated backups.

Orchestrate Python applications in containers with Kubernetes, using pods, deployments, services, config maps, secrets, volumes, and ingress for scalable, declarative runtime.

Explore how containers enable reproducible data science and machine learning workflows using Docker and Kubernetes for development, training, and production deployment at scale.

Launch docker containers to isolate data science projects with images like scipy, numpy, and pandas. Access notebooks via jupyter images with bind mounts and port mappings while noting docker limitations.

Explore how to productionize machine learning models with TensorFlow, TFX, and TensorFlow Serving. Learn to deploy in containers, orchestrate with Kubernetes, and manage data and metadata for scalable inference.

Learn to run Jupyter Notebook in Docker containers for data science, using official Jupyter images with SciPy, Pandas, NumPy, TensorFlow, and Python environment, accessible on port 8888 with token security.

Discover how to run python in jupyter containers using docker compose or docker run, with port mapping and bind mounts across image versions like minimal and scipy.

Explore building a custom Jupyter image with pandas and plotly to analyze world development indicators via the World Bank RESTful API, using docker and docker compose.

Explore TensorFlow in containers using Docker images and Jupyter servers, compare CPU and GPU variants, and set up Docker Compose to run and serve models in production.

Experiment with TensorFlow image classification models in a Docker container, training with Keras on MNIST-style data and saving models for future TensorFlow serving.

Package a trained classification model into a container and deploy a self-contained microservice that serves predictions via a REST API using a TensorFlow Serving image and Docker Swarm.

Experiment with object detection models in a TensorFlow container, using Jupyter to run inference on your own images and compare Mobilenet v1 with faster inception v2.

Explore running GPU-accelerated machine learning in containers with Docker and Nvidia container toolkit, enabling GPU access for Linux-based TensorFlow workflows.