This lecture contains links to all repositories containing the code from the course, as well as the slides used during our discussions.

This lecture focuses on providing a high-level overview of the topics covered in this section.

This lecture focuses on illustrating the value containers offer in simplifying application development and deployment. By contrasting traditional deployment methods with containerization, it seeks to highlight the enhanced efficiency, isolation, and manageability containers provide, ultimately demonstrating why they have become a fundamental technology in modern software development and operations.

In this lecture, we explore the core concepts of containers and virtual machines, emphasizing their similarities and differences. We discuss the architecture of virtualization, the fundamental operations of containerization, and provide criteria for when to use each technology. This understanding equips you with the knowledge needed to implement these technologies effectively in your projects.

In this lecture, we explore the crucial components of a Docker-based system, focusing on the interactions between the Docker client, Docker host, and image registry. By understanding these elements and their relationships, we aim to clarify how Docker functions and how to effectively manage containers and images using various commands.

In this lecture, we explore the functionalities of Docker commands related to pausing and unpausing containers, alongside methods for stopping and cleaning up container resources. You will learn how these actions affect data retention and memory handling in Docker, enhancing your overall understanding of container management.

In this lecture, we guide you through the step-by-step process of installing Docker Desktop on a Mac. By the end of the session, you will have Docker fully set up and running on your system, ready for you to start working with containers.

In this lecture, we cover the necessary steps to install the Docker engine on Ubuntu. You will learn about system requirements, how to uninstall previous versions if necessary, and the different installation methods available. By the end of the session, you will have Docker ready for use on your machine.

In this lecture, we cover the post-installation steps for Docker Engine, focusing on how to manage Docker as a non-root user. By following the steps outlined, you'll enable smoother interaction with the Docker daemon without the need for sudo, enhancing your overall experience as you work with Docker.

In this lecture, we guide you through the step-by-step process of installing the Windows Subsystem for Linux (WSL) on Windows. This will make it easier for you to follow the course by being able to run all the commands in a UNIX-based shell (Linux).

In this lecture, we go through several important features of the Windows Subsystem for Linux (WSL) utility, as well as how to integrate it with Visual Studio Code.

In this lecture, we explore the steps for installing Docker Desktop on Windows, providing various options based on system specifications while ensuring you have the tools needed to start working with Docker effectively.

In this lecture, we explore the integration of Docker with the Windows Subsystem for Linux (WSL). Participants learn to verify and enable settings that allow Docker to function seamlessly across both Windows and Linux environments, and we cover the essential commands to test the setup effectively.

In this lecture, we explore the use of Docker's online playground, allowing participants to create temporary sandbox environments for experimentation. We discuss how to set up a session, manage instances, and execute Docker commands while emphasizing security considerations.

In this lecture, we focus on the installation of Node.js, guiding you through the simple steps needed to get it running on your machine. By the end, you'll have Node.js and npm installed, ready for the upcoming exercises.

In this lecture, we explore the use of Postman, a powerful API client, to send various types of API requests. You'll learn how to download, install, and configure Postman, as well as familiarize yourself with sending GET, POST, and other requests, alongside managing headers and request bodies.

In this lecture, participants explore the setup and installation of Visual Studio Code as their integrated development environment. The focus is on downloading the IDE, installing it, and utilizing extensions to enhance functionality, particularly for technologies like Docker and Kubernetes.

In this lecture, we introduce you to the fundamentals of Docker by guiding them through the process of running their first container using the NGINX web server. We cover essential Docker commands such as "docker pull", "docker run", and "docker ps", providing a hands-on experience to ensure a solid foundation in containerization.

In this lecture, we explore the lifecycle of Docker containers by discussing key commands and their functions. We learn how to create, start, pause, stop, and remove containers while understanding the significance of exit codes and the implications of different container states.

In this lecture, we explore many Docker CLI commands, emphasizing container and image management. By the end of the session, you will be equipped to handle Docker images and containers efficiently, enabling you to maintain a clean and effective development environment.

In this lecture, we explore more advances Docker CLI commands for managing containers and images, including running NGINX in detached mode, viewing and following logs, executing commands within containers, and creating a simple Dockerfile to build a custom image.

In this lecture, we focus on the significance of the "--help" flag in Docker CLI, emphasizing how it can aid in discovering available commands and their options. By the end, you'll gain a better understanding of how to use this feature effectively to enhance your command-line experience.

In this lecture, we go through the main goals and implementation guidelines for the project, also giving you the opportunity to try implementing this project on your own before watching the following videos!

In this lecture, we focus on the essential steps to pull and run the NGINX web server using Docker. You'll learn how to download a specific image version to maintain consistency, run a container in detached mode, and verify that everything is working properly.

In this lecture, you will learn how to modify an NGINX container by installing a text editor and editing the homepage file. By executing commands and navigating the terminal, you gain hands-on experience in Docker, enhancing both your understanding and skills.

In this lecture, we discuss the limitations of manually executing commands in Docker containers and explore recommended practices for efficiently managing containers. The session emphasizes the importance of automation, persistent storage, and documentation to enhance your Docker experience.

In this lecture, we cover the basics of Docker images, explaining what they are, their components, and how they serve as templates for containers. Students learn to create custom images using Dockerfiles and understand the process of packaging applications along with their dependencies and runtime requirements.

In this lecture, we explore the concept of container registries, discussing their advantages, various types like public and private registries, and relevant security features. We also cover important considerations such as cost models and deployment strategies, providing a comprehensive overview of how to effectively utilize container registries in your workflows.

In this lecture, we explore Docker Hub, the largest container registry, and discuss how to efficiently locate and work with container images. We cover the significance of image tags, the importance of pinning image versions for stability, and best practices for maintaining updated images for security.

In this lecture, we cover the essential steps to create a Docker Hub account, log in to the Docker CLI, and manage Docker images through search and pull commands. The goal is to familiarize you with the foundational tools and methods necessary for effective interaction with Docker and its image repository.

In this lecture, we explore the essential concepts and commands related to managing Docker images through the CLI. Students learn about image tagging, pulling and removing images, and pushing images to Docker Hub, ultimately aiming to build a strong foundation in image management practices within Docker.

In this lecture, we explore the structure and advantages of Docker files, emphasizing their importance in creating reproducible Docker images. We discuss the essential instructions like "FROM" and the sequence in which they execute, as well as benefits such as automation, reproducibility, and optimization opportunities. The goal is to establish a solid understanding of Docker files as a foundational concept in our course.

In this lecture, the focus is on creating a Dockerfile to automate and streamline the setup of an NGINX server along with essential dependencies. We aim to draw parallels between manual installation commands and their equivalent Docker instructions, enhancing comprehension of Docker’s automated workflows.

In this lecture, we explore how to create a custom "index.html" file and copy it into a Docker image for an NGINX web server. The goal is to understand file management within Docker containers and automate the process effectively.

In this lecture, we explore the differences between Docker images and containers, emphasizing the practical steps needed to manage and update them effectively. Through hands-on experience, you'll learn to create, modify, and version Docker images, as well as their impact on running containers.

In this lecture, you will learn how to build and serve a React application using Docker's multi-stage builds. The focus will be on creating a Dockerfile that efficiently builds the application and utilizes NGINX for serving the final product, while also discussing deployment strategies for seamless updates.

In this lecture, we focus on building a basic Express application using Node.js. We go through initializing a project, installing necessary packages, and setting up a server that responds with a simple message. The goal is to provide students with a solid understanding of how to create and run an Express app from scratch.

In this lecture, we focus on implementing user registration and retrieval in a JavaScript application. We discuss how to create POST and GET routes, handle user input validation, and manage arrays effectively to store registered users. The goal is to equip you with the skills to enhance your application and understand basic routing principles in JavaScript.

In this lecture, we test the functionality of our application by interacting with the server using Postman. Students will learn how to perform GET and POST requests, handle responses, and manage potential errors effectively.

In this lecture, you learn how to write a Docker file for an Express application, exploring concepts like defining base images, setting working directories, copying dependencies, and running applications in containers. You'll gain hands-on experience in Dockerizing an application, preparing you for more advanced topics in containerization.

This lecture explores Docker's layered architecture by examining a Dockerfile from a containerized Express app. Participants learn how each instruction in the Dockerfile creates individual layers in the final image, methods to visualize these layers, and strategies for image optimization based on the analysis of both their own and the base images.

In this lecture, we explore build contexts in Docker, focusing on how they affect the image-building process. Through hands-on examples, we demonstrate the importance of defining the correct context and how to optimize images using ".dockerignore" files.

In this lecture, we learn how to utilize Docker Ignore files to exclude unnecessary files from the build context while building Docker images. Through hands-on examples, we demonstrate the practical steps involved in setting up a project directory, creating a ".dockerignore" file, and verifying the exclusion of specific files from the final image.

In this lecture, you discover how to pass environment variables to Docker containers through a hands-on exercise where you create a simple Express application. You learn the importance of environment variables and explore different methods of implementing them in your Docker setup.

In this lecture, we explore the use of environment variables within Docker. We focus on how to set default values in a Dockerfile, override them during container creation, and the best practices for managing these variables for a more flexible application setup.

In this lecture, we explore the process of using .env files for managing environment variables in Docker. The session covers the creation of production and development configuration files and emphasizes the importance of maintaining security by preventing sensitive information from being included in Docker images. Through practical examples, students gain hands-on experience with Docker commands and workflows.

In this lecture, we examine the differences between CMD and ENTRYPOINT instructions in Dockerfiles. We create multiple Dockerfiles to better understand how these commands work independently and together, enabling better container management and flexibility.

This lecture explores the foundations of Distroless Images, and what makes them different from traditional Docker images. We also discuss advantages and disadvantages of working with Distroless Images, understanding the trade-offs that using this class of images brings to our projects.

In this lecture, we explore multi-stage builds in Docker, discussing their significance in creating efficient and secure images. Students will learn how to implement multi-stage builds by setting up a simple Node.js application with Docker, incorporating best practices for image optimization.

In this lecture, we explore the concept of multi-stage builds in Docker, specifically focusing on using distroless images with Node.js. Students will learn how to separate the dependency installation process from the running application, improving the build efficiency and enhancing security.

In this lecture, we focus on integrating TypeScript into an existing Docker project using multi-stage builds. We cover the necessary steps to install TypeScript, configure the project settings, and ensure that the application functions correctly with TypeScript-based syntax.

In this lecture, we focus on updating the Dockerfile to effectively integrate TypeScript into our project. We cover essential steps like modifying the Docker Ignore file, adjusting COPY commands, and ensuring that the build process compiles TypeScript files correctly, ultimately leading to a functional Docker setup for TypeScript applications.

In this lecture, we discuss practical strategies for optimizing Docker images, focusing on reducing image sizes while maintaining functionality. Key topics include selecting appropriate base images, understanding the impact of development dependencies, and demonstrating these principles through hands-on examples.

In this lecture, we explore the importance of command ordering in Dockerfiles for optimizing image build times. Using practical examples, we demonstrate how to structure your Dockerfile to take advantage of Docker's caching mechanism, leading to more efficient builds and a smoother development process.

In this lecture, participants learn how to optimize Docker images by installing only the necessary runtime dependencies, minimizing image size, and enhancing security. We explore practical modifications to Dockerfiles and demonstrate the impact of using production-only dependency installations.

In this lecture, you learn how to revisit and optimize a Dockerfile using multi-stage builds to manage production and development dependencies effectively. You'll gain hands-on experience with structuring your Dockerfile for efficiency, ensuring that only the necessary files are included in your final image while adhering to best practices.

In this lecture, we learn how to set up a React application using Docker, focusing on creating an app with Create React App, understanding the NPM start command, and gaining insights into the underlying processes like hot reloading and webpack dev server. The goal is to prepare for serving the application in a production environment.

In this lecture, we explore how to build a React application by creating an optimized production build and serving it locally using an HTTP server. Students gain hands-on experience with the build process and learn to navigate the output files effectively.

In this lecture, we explore the process of creating a multi-stage Dockerfile for a React application. You will learn how to build and serve a production-ready build, handle necessary configurations, and understand the structure that enables efficient containerization of your app.

In this lecture, we cover the different types of restart policies available in Docker, explaining how to use each type effectively. Students learn to manage container restarts based on their exit status, helping to ensure that applications maintain high availability and resilience.

In this lecture, we explore the motivation behind using Docker volumes for data persistence. We demonstrate how to create an NGINX container, create a file within it, and investigate the implications of stopping and removing containers on data storage. By the end of the session, participants will understand how Docker volumes provide a solution for managing persistent data across container life cycles.

This lecture delves into Docker volumes, focusing on their role in data persistence and sharing between containers. It highlights the types of volumes available and provides hands-on exercises to help reinforce these concepts. Through this session, learners gain insights into managing data effectively within Docker environments.

In this lecture, we explore how to utilize Docker bind mounts for a containerized React application, allowing for efficient local development with automatic hot reloading. We cover the setup of a development Dockerfile and the necessary commands to run the application smoothly within a Docker container.

In this lecture, we explore named volumes in Docker, focusing on their role in data sharing between containers. You learn how to create and use volumes to persist data and observe the effects of changes made in one container reflected across others. We also touch on horizontal scaling through the use of shared volumes, making it a vital concept for containerized applications.

In this lecture, we explore the fundamentals of managing Docker volumes using the Command Line Interface. You'll learn how to create, list, inspect, and remove volumes, as well as how to clean up dangling volumes for efficient data management.

In this lecture, we explore how to set CPU constraints on Docker containers to optimize system resource usage. We focus on various options available within Docker for controlling CPU allocation, including CPU shares, setting limits with the "--cpus" option, and using "CPU quota" and "CPU period" for more granular management. By the end of the session, learners will have hands-on experience in implementing and monitoring CPU constraints effectively.

In this lecture, we examine memory allocation for Docker containers, focusing on how to set memory limits, reservations, and swap options. By the end of the session, you will understand best practices for managing memory usage to ensure reliable application performance.

In this lecture, we discuss the basics of Docker networking, including the importance of container communication, the different types of network drivers available, and how to create and manage custom networks. Students learn how to effectively use Docker's networking capabilities to ensure secure and efficient inter-container communication.

In this lecture, we explore essential networking concepts in Docker, focusing on the default bridge network. We discuss its functionality, limitations, and demonstrate how to connect Docker containers via IP addresses while highlighting the absence of DNS resolution within the default setup. By the end of the lecture, you'll have practical experience using the Docker network commands and understanding the bridge network's capabilities and constraints.

In this lecture, we explore the creation and management of user-defined networks in Docker, focusing on how to connect containers and facilitate communication among them. The goal is to understand the significance of networking in Docker and how to take advantage of these features to build robust applications.

In this lecture, we focus on using Docker's host network and understanding port bindings when running containers. By running NGNX containers and managing network settings, we gain insight into the importance of isolation and security in containerized environments.

In this lecture, we focus on setting up a basic MongoDB server through Docker. Participants will learn how to pull the appropriate MongoDB image, run a container, and interact with the server via the Mongo shell while discussing considerations for security and reliability.

In this lecture, you learn how to set up a MongoDB server with root username and password using shell scripts. You will explore defining variables, modifying Docker commands for improved management, and implementing basic security measures. This knowledge will aid you in effectively managing and securing your MongoDB environment.