Docker Overview and Image Building

The process of packaging an application and its dependencies into a self-contained unit that can be run on any system with Docker installed.

A file called 'Dockerfile' that provides instructions to Docker on how to build an image from the app's source code.

A specific port on which the app listens for incoming requests. In this case, the app runs on port 8080 inside the container.

A language-agnostic tool, meaning it works with any programming language or framework.

The act of packaging dependencies for an app into a container image, allowing it to run independently on any system with Docker.

A virtual environment that isolates the app and its dependencies from the host system, providing a consistent and predictable runtime.

A collection of files and commands that represent the state of an application at a specific point in time. It serves as a blueprint for creating containers.

A platform for sharing and discovering container images. It allows developers to publish and download images for different applications.

A container image contains the application's code, dependencies, and configuration files all neatly packaged into a format that makes it easy to share and run.

A specialized container image that comes pre-installed with Node.js and other tools.

A Docker command that builds a container image based on the instructions in a Dockerfile.

The entry point is the command that's executed when the container starts. It defines the app's main process.

The process of copying files from your local machine into the container image being built.

A command used inside a Dockerfile to set the working directory inside your container.

A command used inside a Dockerfile to install dependencies from a package.json file.

This command is used inside a Dockerfile to run the application or command once the container is started.

A common package manager used for managing dependencies in Node.js applications.

The process of fetching a repository from a remote server to your local machine.

A version control system that helps track changes to code and collaborates with others on software projects.

A unique identifier used to distinguish different users on Docker Hub.

Docker Desktop on macOS and Linux is pre-configured for Linux containers, so no additional setup is needed.

A collection of files and instructions that describe an application's state at a specific time. Think of it as a blueprint for making containers.

A simple, plain-text file that contains a set of instructions Docker follows to build an image. It's like a recipe for creating a running container.

Docker uses a specialized container image that includes Node.js and other tools for building Node.js apps. It's a pre-built starting point for your container.

This command lets you create a Docker image. It builds the image from the Dockerfile instructions and packages your code into a container image.

A virtual directory inside the container image where you can install your application's dependencies.

The ENTRYPOINT in a Dockerfile specifies the command to run when you start a container based on that image. It's like telling Docker what your app should do when you launch it.

The . in the Dockerfile's COPY instruction tells Docker to copy all files and folders from the current directory where you run the docker build command. It's like telling Docker to copy everything from your current project.

Container images share the kernel of the host operating system. This means you don't need to include a kernel within the container image itself. It's a way to save resources on your system.

A platform where users can share and discover container images. It allows developers to publish and download images for different applications.

This is the set of files and dependencies that are put together in a container image. You can think of it as a ready-to-run bundle of your application.

A unique identifier that helps distinguish different container images. It's usually a combination of username and repository name, separated by a colon, followed by a tag.

This line in the Dockerfile sets the working directory within the container, where the app's commands should run.

Docker doesn't care what programming language you use for your application, as long as it can be built into an image and run in a container.

A packaged, self-contained unit that includes an application and its necessary dependencies, making it easy to run the application consistently across different environments.

A unique identifier that distinguishes your Docker images from others on Docker Hub, helping you organize and manage them.

A command used to build a Docker image from a Dockerfile. It packages an application and its dependencies into an image.

A command used to push a Docker image to a registry, making it available for other users to download and run.

A command used to pull a Docker image from a registry, allowing you to run that image on your local machine.

A command used to run a container from an image. It starts the container and makes the application inside it available.

A command used to delete a Docker image from your local machine. It removes the image and its associated data.

A way to specify different architectures for your container image. For example, building for both ARM and AMD processors.

An organization responsible for the standardization of containers, including the specifications for container images and registries.

A format for storing and distributing Docker images, ensuring compatibility and interoperability across different platforms.

A platform where you can store containers that you have built, allowing you to share them with others and deploy them easily.

A command used to log in to a registry, such as Docker Hub, allowing you to push and pull images.

A command used to log out of a registry, disconnecting your account.

A mapping between ports on the host machine where Docker is running and ports inside the container. This allows external access to services within the container.

A process that stops a container and allows for a graceful shutdown of the app running inside. It sends a signal to the app to terminate gracefully within a specified time limit.

A Docker command that restarts a container. It resumes the execution of the app within the container.

A Docker command that removes a container from the system. It permanently deletes the container and its associated data.

A Docker flag that tells Docker to run a container in the background, detached from the terminal. This allows the container to continue running even if the terminal session is closed.

A Docker flag that runs a container interactively and attaches a terminal to it. This allows you to interact with the container's shell.

The container's main process. By default, Docker uses the entrypoint specified in the Dockerfile. However, -it flag overrides this and runs the specified process instead.

A command that exits the interactive shell within a container, effectively terminating it. This is because the shell is the main process of the container.

A keyboard shortcut used to gracefully exit a container's interactive shell without immediately terminating it. This allows the container to continue running after you disconnect.

A Docker flag that forces the termination of a container, even if it is currently running. This bypasses the graceful shutdown process.

A term referring to an application that is packaged and run in a container. This allows the application to run consistently across different environments.