Docker and Kubernetes for Network Engineers

Explore container networking fundamentals in Docker and Kubernetes, providing an overview tailored for network engineers.

Set up a docker and kubernetes lab with ubuntu hosts and kali client, accessing F5, Cisco, and Arista devices via ssh and sftp in Eve Energy.

Present a container network topology with three docker hosts on the 192.168.10.0/24 data network, connected through Arista and Nexus switches, and an F5 Big-IP VE for external and internal networks.

Explore the management network topology on a 192.168.254.0/24 network, listing host IPs for Docker/Kubernetes master and worker nodes, Kali and Ubuntu clients, and switches, with the 192.168.254.254 gateway.

Access the lab resources, download the Docker and Kubernetes yaml zip, unzip, and upload to the master node and Docker host via FileZilla, or create them by copy-paste.

Master Docker basics through a simple topology and a basic lab focused on creating containers on Docker host one. We postpone other components to the next section.

Compare virtualization and containerization, focusing on native hypervisor virtualization versus host-based options. See how VMware ESXi and the virtual switch run VMs on bare metal, reducing cost and simplifying management.

Explore containerization as an alternative to host-based virtualization, showing how containers run on a Linux host with a container engine, using isolated namespaces and minimal libraries to deliver lightweight applications.

Explore host-based versus native virtualization using a nested ESXi lab in VMware Workstation, viewing VMs, storage, and networking with virtual switches, VLANs, port groups, and iSCSI.

Compare Docker with other container options, noting Docker's multi-platform and multi-vendor support. Describe the Docker engine's components—client, daemon, containerd, runC, and shim—and how they create, run, and manage containers.

Explore how Docker's daemonless container engine simplifies building, deploying, and migrating applications across cloud and data center production, with strong ecosystem support for developers, DevOps, and network teams.

Explore Docker components, including the client, daemon, images, containers, and registries (public and private), with Docker Hub as the default registry, and essential commands for management.

Learn to verify docker installation and components, inspect client and server details, and manage containers, images, and swarm status, then navigate Docker Hub to search, create, and push images.

Explore Docker images as the building blocks for containers, including how to pull, inspect, commit, push, and prune them via Docker Hub and local repositories.

Demonstrate pushing and pulling docker images, inspecting and running containers, and using docker commit to create new images for a Zurian workspace, then pushing to Docker hub and cleaning up.

Learn how Docker containers run on the Docker engine from images and dependencies, with network settings and published ports. Use docker run and detach mode to start in the background.

Demonstrate creating and managing docker containers across two sessions, pulling ubuntu and nginx images, running with -it, and stopping and removing containers such as naughty liskov.

Name and detach docker containers with docker run --name, run nginx in the background, then remove containers with docker rm -f and clean up images with docker rmi -f.

Learn how docker compose defines and runs multiple containers with a yaml file, simplifying complex docker commands and saving settings for automated, reusable deployments.

Demonstrates deploying an Nginx web app with Docker run and Docker Compose, exposing port 8080 to Kali Linux, and validating connectivity through a YAML-based setup.

Explore docker networking topology by deploying containers on three hosts, using an overlay network with vxlan tunnels to enable direct inter-host communication from a client.

Docker network architecture gives each container its own IP and port on the default bridge, with a host gateway via docker0; publish host ports to map to container port 80.

Demonstrates running multiple nginx containers on one host, publishing container ports to the host (80, 8081, 8082), testing access from Kali Linux, and resolving port conflicts by rebinding host ports.

Explore the default Docker bridge network, the Docker zero, where containers receive 172.17.0.0/16 addresses, reach each other, and share a gateway at 172.17.0.1 as seen by the host.

Examine how docker bridge network connects web1 and web2 containers, verify IP addresses and port mappings, inspect docker0 gateway, and test reachability including container name ping limitations.

Explore user defined docker networks for isolation and dns resolution, with bridge, overlay, and macvlan drivers; learn to set subnet, ip-range, and gateway, and connect containers.

Create a user-defined bridge network with a specified subnet and gateway, assign a static IP to a container, and connect multiple containers to enable name-based reachability and inter-container ping.

Explore docker overlay networks using vxlan to connect containers across multiple hosts, and learn swarm-based deployment and service scaling.

Initialize a Docker swarm on worker two, join worker three, and create an overlay vxlan network named vnet for swarm services and deploy a two-replica ubuntu service on that network.

Demonstrates validating Docker swarm overlay networking by inspecting multi-host containers on a vnet and verifying connectivity through ping by IP and container names.

Explore Arista container networking by running Docker on an Arista switch, creating Arista container iOS instances, and connecting them via the Docker bridge network to test ICMP connectivity and routing.

Discover how Arista EOS runs Linux on switch hardware, enabling on-switch Docker containers with Bash and Python, including starting Docker, listing containers, and running Nginx with port publishing.

Demonstrates creating and running an nginx container on an Arista EOS switch, starting Docker service with root privileges, exposing port 8081, and verifying connectivity from a Kali Linux client.

Enable container manager in the Arista CLI to view, create, and manage containers with docker-like commands. Define containers with images and options, and use container tracer to view network settings.

Demonstrate container management with Arista container manager and Docker to create, rename, and delete web containers, and configure httpd and nginx images with port mappings, on-boot testing with Kali client.

Download the Arista ceos lab image, import it into docker, create two cos containers, create and attach an arista net, start the containers, and verify their network connections.

Learn how Kubernetes orchestrates containers across multiple Docker hosts to provide scaling, self-healing, and load balancing, complementing Docker rather than replacing it.

Introduces Kubernetes, a Google-born container orchestrator donated to the CNCF, enabling automated deployment, scaling, self-healing, and storage across many Docker hosts with pods, services, and controllers.

Learn the Kubernetes architecture with a master node handling API server, scheduler, and etcd, and worker nodes running containers via kubelet and cube proxy, while kubectl manages cluster resources.

Explore validating a Kubernetes cluster by inspecting master and worker nodes, services, and core components with kubectl, checking etcd, API server, controller manager, kube-scheduler, flannel, and Core DNS.

Explore Kubernetes pods as the atomic unit that groups one or more containers with shared resources, and learn pod design, IP addresses, namespaces, and inter pod communication.

Learn how to create and manage Kubernetes pods using yaml manifests, kubectl commands, and the pod life cycle from pending to running, including static pods and controllers like deployment.

Create a static pod from a yaml manifest using kubectl, delete and recreate the pod, then verify the container runs on the assigned worker node and observe IP provisioning.

Maintain a stable set of replica pods to ensure availability and self-healing when pods fail, by defining a YAML manifest with a selector, template, and replicas.

Create a Kubernetes replica set from a yaml manifest to manage three nginx pods across three worker nodes, then scale to six with kubectl apply while maintaining availability.

Learn how Kubernetes deployments provide declarative updates for pods and replica sets, automatically creating replica sets and pods, with rolling updates, rollbacks, and scaling.

Deploy a Kubernetes deployment from a manifest, verify pods across worker nodes, and observe rolling updates and rollbacks as you downgrade and revert nginx images.

Delete a deployment with cascade=false removes only the deployment, leaving replica sets and pods intact. Without a controller, deleting the replica set or pods prevents automatic recreation, enabling controlled experimentation.

Explore Kubernetes networking by creating pods and services from the master node, deploying to worker nodes, and testing client requests and native load balancing across service types.

Explore Docker bridge, overlay networks, and vxlan for multi-host container communication. See how Kubernetes uses a standard cni with plugins like Flannel or Calico to connect pods across nodes.

Compare bridge, none, and host docker networks and introduce Kubernetes networking with CNI for automated pod connectivity, east-west traffic, and routing across clusters.

Explore Kubernetes network architecture by deploying four nginx pods across three worker nodes using deploy yaml, verifying objects on the master node, and inspecting docker networks with pod-level IP assignment.

Explore how Kubernetes uses CNI to manage pod networking across a multi-node cluster, with VXLAN overlays and plugins like Flannel and Calico.

Verify Kubernetes networking at the node level with the Flannel CNI, and validate pod connectivity across worker nodes via the 10.244.x.x networks.

Learn how Kubernetes services connect groups of pods and expose applications to external users via cluster IP, node port, or load balancer, as cluster-wide virtual objects in manifests.

Explore how Kubelet, the scheduler, and API server coordinate pod creation, with the Flannel CNI linking nodes and the Kube proxy mapping service IPs to pods for load balancing.

Create and verify a dedicated Ubuntu pod, test pod-to-pod connectivity with ping and curl, and configure a cluster ip service web-svc linked to the web deploy deployment on port 80.

Describe how the cluster IP service enables internal pod-to-pod communication via a virtual IP and port, while external access uses node port, load balancer, or an nginx ingress controller.

Demonstrates recreating a clusterIP service, validating internal access via curl, and observing load balancing across nginx pods behind the service in a Kubernetes cluster.

Create a nodeport service using a manifest to expose three Nginx pods. Validate how nodeport forwards external requests to the service and pods via tcp.

Expose web pods externally by converting the service to node port, specify a node port (for example 30080), and verify connectivity across worker nodes with curl.

Examine Kubernetes load balancer options from native cloud load balancers to external devices and ingress controllers, and learn why master node load balancing is for testing, not production.

Delete the node port service, deploy a load balancer with an external ip on the master node, then scale replicas from two to four and verify pod load balancing.

Kubernetes ingress exposes http and https routes from external networks to internal services, using ingress rules and the nginx ingress controller (not a load balancer), with verification via kubectl.

Activate the nginx ingress controller on bare metal Kubernetes, deploy four pods, expose via a cluster IP service, and create a web ingress while troubleshooting missing ingress IP addresses.

Use metallb on bare metal to assign an external ip for the ingress engine x controller, switch the service to load balancer, and verify external access.

Explore running containers on Cisco Nexus 9000 within a Kubernetes lab, test client access to applications, and connect the Nexus 9000 to the Kubernetes API server with Cisco Container Tracker.

Explore nx-os on nexus 9000 switches, harnessing docker and lxc containers with bash and linux tools for automation, inventory, configuration consistency, and kubernetes integration.

Demonstrates running Docker on NX-OS by enabling the Bash shell, configuring DNS and routes, and launching an nginx container that is accessible from the Kali Linux host.

Cisco container tracker on Nexus 9000 enables verification of pods and Kubernetes clusters via the Kubernetes API server, with commands like show kubernetes container brief and show kubernetes containers interface.

activate Cisco container tracker on the nexus 9000 nx-os, validate reachability to the kubernetes api server at 192.168.10.10:6443, and test container data retrieval with container_tracker.py.

Discover Cisco ACI as a scalable, automated software-defined fabric with APIC-driven policies, spine-leaf topology, and application profiles, then integrate Kubernetes via the ACI CNI to manage pods.

Explore how Cisco ACI delivers scalable, automated data-center networking with spine-leaf fabric and APIC central policy, and how ACI CNI enables Kubernetes networking and policy across containers.

Discover how Cisco UCS uses fabric interconnect, UX manager, and service profiles to boot blade and rack servers from storage, and how Hyperflex with CCP enables Kubernetes via Intersight.

Explore Cisco UCS and Hyperflex with fabric interconnect and service profiles, then deploy and manage Kubernetes clusters across data centers via the Intersight Kubernetes Service cloud portal with automation.

Explore Calico CNI within a Kubernetes slab topology, enabling routing and BGP sessions from Cisco Nexus 9000 to every node so clients reach pods directly without services.

Explore how Calico as a CNI enables direct pod reach from external networks by enabling BGP peering with an upstream layer 3 device and advertising pod networks.

Calico CNI delivers a full network stack with layer 2/3 networking and policy enforcement for containers, VMs, and host workloads, enabling micro-segmentation, zero-trust security, and multi-cloud BGP routing.

Migrate from flannel to Calico by deleting the old CNI and applying the Calico manifest, then verify pods and IPs in 172.11.0.0/16 with Calico ctl.

Verify the existing CNI across all namespaces, remove Flannel, install Calico with calico.yaml, then use CalicoCtl to confirm nodes master and workers 1–3 are recognized.

Calico BGP configuration enables Kubernetes nodes to advertise internal container IP addresses to layer three devices, using BGP config and BGP peer manifest files.

Enable Calico BGP dynamic routing by creating BGP configuration and peer manifests, deploying pods, and verifying learned networks on the Nexus 9000.

Demonstrates troubleshooting pod reachability in a Kubernetes cluster using calico BGP configuration, adding a static route for 10.244.0.0/16 via the Nexus 9000 switch, then testing with ping and browser access.

Wrap up by reviewing container networking topologies for Docker, Kubernetes, and F5, and summarize the lab environment, Calico migration from Flannel, and F5 automation.

Supplement certified Kubernetes administrators and F5 professionals by this course, introducing F5 101 and 201 exams, and outlining future Docker and Kubernetes courses.

Celebrate completing the docker and kubernetes for network engineers course and share your feedback. Rate five stars and explore the instructor's cloud data center and cyber security courses.

Conclude the Docker and Kubernetes for network engineers course, reinforcing core containerization concepts and preparing learners for successful course completion.