Docker Cheat Sheet for Beginners

Docker is a tool designed to make it easier to create, deploy, and run applications using containers. Containers allow you to package up an application with all parts it needs, such as libraries and other dependencies, and ship it all out as one package. Here’s a quick and easy-to-understand cheat sheet to get you started.

What is Docker?

Docker is a platform for developing, shipping, and running applications in containers.
Containers are lightweight, portable, and self-sufficient environments that run applications and their dependencies.

Key Concepts in Docker

Docker Image: A read-only template used to create containers. For example, an image could contain a Python application, including everything it needs to run.
Docker Container: A running instance of a Docker image.
Dockerfile: A text file that contains all the instructions to build a Docker image.
Docker Hub: A registry for sharing Docker images. You can pull or push images from and to Docker Hub.

Common Docker Commands

Basic Docker Commands

Check Docker Version

docker --version

List Docker Images

docker images

List Running Containers

docker ps

List All Containers (including stopped ones)

docker ps -a

Run a Container

docker run <image-name>

Stop a Running Container

docker stop <container-id or container-name>

Remove a Container

docker rm <container-id or container-name>

Remove an Image

docker rmi <image-id or image-name>

Working with Docker Images

Pull an Image from Docker Hub

To pull a pre-built image from Docker Hub:

docker pull <image-name>

Build an Image from a Dockerfile

1. Create a Dockerfile with instructions. Example Dockerfile:

FROM ubuntu:latest 
RUN apt-get update && apt-get install -y python3 
COPY app.py /app.py 
CMD ["python3", "/app.py"]

2. Build the image:

docker build -t <image-name> .

Running Containers

Run a Container in Interactive Mode

docker run -it <image-name> bash

This command runs a container and opens a bash terminal inside it.

Run a Container in Detached Mode

docker run -d <image-name>

This runs the container in the background (detached mode).

Expose Ports

To expose a container’s port to your local machine, use the -p flag:

docker run -p <host-port>:<container-port> <image-name>

Docker Networking

Create a Custom Network

docker network create <network-name>

Connect a Container to a Network

docker network connect <network-name> <container-name>

Docker Volumes

Docker Volumes allow you to persist data across container restarts. Here’s how to create and use volumes:

Create a Volume

docker volume create <volume-name>

Mount a Volume

docker run -v <volume-name>:/path/in/container <image-name>

List Volumes

docker volume ls

Docker Compose (For Multi-Container Applications)

Docker Compose allows you to define and manage multi-container Docker applications.

Check Docker Compose Version

docker-compose --version

Example `docker-compose.yml` file

version: '3'
services:
  web:
    image: nginx
    ports:
      - "8080:80"
  db:
    image: postgres
    environment:
      POSTGRES_PASSWORD: example

Start Services Using Compose

docker-compose up

Stop Services Using Compose

docker-compose down

Dockerfile Example

A basic Dockerfile example for a Python app:

1. Create a directory for your app.

2. Add an app.py (your Python app) and the following Dockerfile:

# Use the official Python base image
FROM python:3.9-slim

# Set the working directory inside the container
WORKDIR /app

# Copy the local app.py to the container
COPY app.py /app

# Install dependencies
RUN pip install flask

# Command to run the app
CMD ["python", "app.py"]

3. Build and run the image:

docker build -t python-app .
docker run -p 5000:5000 python-app

Cleaning Up

Remove Stopped Containers

docker container prune

Remove Unused Images

docker image prune

Remove Unused Volumes

docker volume prune

Conclusion

With this cheat sheet, you should be able to get started with Docker and begin working with containers, images, and even multi-container applications. Practice is key — try running your own containers, creating Dockerfiles, and experimenting with Docker Compose to deepen your understanding. For more in-depth information, you can refer to Docker’s official CLI documentation at Docker CLI Reference.

Comments

Understanding Number Systems: Decimal, Binary, and Hexadecimal

In everyday life, we use numbers all the time, whether for counting, telling time, or handling money. The number system we’re most familiar with is the decimal system , but computers use other systems, such as binary and hexadecimal . Let’s break down these number systems to understand how they work. What is a Number System? A number system is a way of representing numbers using a set of symbols and rules. The most common number systems are: Decimal (Base 10) Binary (Base 2) Hexadecimal (Base 16) Each system has a different “base” that tells us how many unique digits (symbols) are used to represent numbers. Decimal Number System (Base 10) This is the system we use daily. It has 10 digits , ranging from 0 to 9 . Example: The number 529 in decimal means: 5 × 1⁰² + 2 × 1⁰¹ + 9 × 1⁰⁰ = 500 + 20 + 9 = 529 Each position represents a power of 10, starting from the rightmost digit. Why Base 10? Decimal is base 10 because it has 10 digits...

How to Monetize Your API as an Individual Developer While Hosting on Your Own Server?

In the API economy, cloud services like AWS, Google Cloud, and Azure offer many conveniences, such as scaling and infrastructure management. However, some developers prefer more control and autonomy, opting to host their APIs on personal servers. Whether for cost efficiency, data privacy, or customization, hosting your own API comes with both advantages and challenges. But, even without cloud platforms, there are effective ways to monetize your API. This guide will explore how individual developers can successfully monetize their APIs while hosting them on their own servers. Why Host Your API on Your Own Server? Hosting your own API gives you full control over the infrastructure and potentially lower long-term costs. Here’s why some developers choose this approach: Cost Control : Instead of paying ongoing cloud fees, you may opt for a one-time or lower-cost hosting solution that fits your budget and resource needs. Data Ownership : You have full control over data, which is critical if ...

API Testing with Jest and Supertest: A Step-by-Step Guide

API testing is essential to ensure your endpoints behave as expected across all scenarios. In this guide, we’ll explore how to use Jest and Supertest to test a sample API with various response types, including success, authentication errors, and validation errors. By the end, you’ll understand how to apply these tools to check for different response structures and status codes. 0. Prerequisites: Setting Up Your Environment Before diving into API testing, it’s important to ensure that your development environment is properly set up. Here’s what you need to do: Step 1: Install Node.js and npm Node.js is a JavaScript runtime that allows you to run JavaScript code on the server side. It comes with npm (Node Package Manager), which helps you install and manage packages. Installation Steps: Download and install Node.js from the official website . To verify the installation, open your terminal and run: node -v npm -v This should display the installed versions of Node.js...

The Weight of Responsibility: A Developer’s Journey to Balance Passion and Reality

For the past several years, Eddie has been on a steady climb in his career as a developer, but recently, he found himself at a crossroads — caught between the weight of his responsibilities and the desire to pursue his true passions. His journey began with a three-month internship as a web developer, which led to nearly four years in an application developer role. After that, he spent almost a year as a systems associate, managing tasks across systems analysis, quality assurance, and business analysis. Eventually, he returned to full-time software development for another two years before transitioning into more complex roles. For over a year, he worked as a multi-role software developer and database administrator before stepping into his current position as a senior software developer, database administrator, and cloud administrator — occasionally handling security tasks as well. Now, with over 8 years of professional experience, he also leads a small team of developers, which has been...

Avoiding Confusion in API Design: The Importance of Clear Responses

In today’s fast-paced software development landscape, APIs play a crucial role in connecting services and enabling functionality. However, poor design choices can lead to confusion and inefficiency for both developers and users. One such choice is the omission of a response body for successful requests, a practice I recently encountered in an enterprise API designed for bill payments. The Case of the No-Response API The API in question serves two main endpoints: one for inquiring about account validity and another for confirming payment. When successful, the API returned a 200 OK status but no response body. This design choice led to significant confusion during our integration process. Even the internal team who developed the said API struggled to justify this approach, revealing a lack of clarity around the rationale behind it. Pros of This Design Choice While the intention behind this design may have been to streamline responses, several potential benefits can be identifi...

mvryo