Docker for Beginners: Containers, Installation and Persistent Data

Docker provides tools to build, distribute and run applications in containers. Docker Engine and the Docker Desktop application are different products, so their installation requirements and licensing should not be treated as identical. We have an article on Containers in Servers from a while back, should you want a bit more information on containers in the server space. Think of an image as a package containing application code, dependencies and defaults, and a container as a running or stopped instance created from that image. External data, runtime configuration, secrets and compatible infrastructure can still be required. Images help deployments behave consistently across compatible machines. Architecture, Linux-versus-Windows container support, device access and external services still affect portability.

Containers are different from virtual machines (VMs) in that they don’t require a full operating system to run, which makes them more efficient in terms of resources and speed. A VM normally boots its own guest kernel. Linux containers share the Linux kernel of the environment running them and include their own user-space files. Docker Desktop can provide that Linux environment in a VM, including on Windows and macOS; it is not a Linux image running directly on an unrelated native kernel.

Why Use Docker for Servers and Workstations?

Docker on Servers

Docker is highly beneficial for server environments where multiple applications or services run side by side. It simplifies application deployment, making it easier for developers to manage updates and changes across various machines. Additionally, because containers are isolated, they help reduce potential conflicts between applications, increasing security and system stability.

Docker on Workstations

Docker is equally valuable on workstations for testing, development, and running various applications without cluttering the main system. Developers can use Docker to test different versions of software while keeping the environments more separate. Images and host features still need to be compatible. This makes it ideal for creating clean, reproducible environments for coding, data science, or simply running isolated apps without affecting other software on the machine.

Benefits of Using Docker

Here are some of the main advantages of Docker:

Portability: Use an image built for a supported operating-system/CPU architecture, or a suitable multi-platform image. Installing Docker does not make every Linux or Windows image run natively everywhere.
Efficiency: Because containers share the host system’s kernel, they use fewer resources than traditional VMs, making them faster to start and more efficient to run.
Isolation: Each Docker container runs in its own environment, minimizing compatibility issues and preventing conflicts.
Scalability: Multiple instances and orchestration can help scale suitable applications. Shared data, load balancing, resource limits and the application design still need to support it.

Considerations When Using Docker

While Docker offers numerous advantages, there are a few things to keep in mind:

Data Persistence: A container's writable layer survives an ordinary stop/start but is lost when that container is removed. Store important application data in planned volumes or bind mounts, then back it up separately. Persistence alone is not a backup.
Security: Docker relies on the host’s kernel, which can lead to security vulnerabilities if not properly managed. Regular updates and proper permissions are essential.
Learning Curve: Although Docker is powerful, it can take time for new users to learn. Understanding basic commands, configurations, and Dockerfile syntax may require some effort.

Installing Docker on Linux

Choose the installation page for your actual distribution from the Official Docker Install Docs. Ubuntu repository commands are not universal Linux commands, and mixing an older repository definition with a newer installation can create conflicting sources.

Check support and existing packages: Confirm the supported OS release and architecture, and review conflicts with distribution-provided Docker, containerd or Podman compatibility packages. Preserve existing application data before changing an established installation.
Configure the documented repository: Use the current signing-key and package-source procedure for that distribution. Docker's current Ubuntu guide uses its own key and a docker.sources definition; Debian and other distributions have their own instructions.
Install the required components: Follow the selected procedure for Engine, CLI and containerd, with Buildx and the Compose plugin where required. Check each package operation succeeds before continuing.
Verify the daemon, not only the CLI: A version string shows that the client command exists; running the publisher's test image also checks pulling and container execution.

sudo docker run --rm hello-world

On a standard rootful Linux installation, use sudo until you deliberately choose an access method. Adding a user to the docker group grants powerful, root-level daemon access; it is not a harmless routine permission fix. Rootless mode is a separate supported option with its own requirements. A repository-key procedure or install script should be read and understood before it is run with elevated privileges.

Installing Docker on Windows

To install Docker on Windows, follow these steps:

Download Docker Desktop for Windows from the Docker website.
Run the Installer and follow the setup instructions.
Choose the supported installation mode and backend for your OS, hardware and container needs; current options are described below.
Finish the Installation and restart your computer.
Launch Docker Desktop to start using Docker on Windows.

Hyper-V vs. WSL 2 for Docker on Windows

Current Docker Desktop documentation describes WSL 2, Hyper-V and Docker VMM, with the latter marked as beta. WSL 2 is a usual starting point, but supported OS versions, architecture and per-user versus all-user installation modes affect the available options. Use the current Windows installation page rather than assuming every Windows edition and release supports every backend.

WSL 2 runs a real Linux kernel in a managed virtualized environment; it is different from WSL 1's compatibility approach. Linux-container and Windows-container modes also have different requirements. Docker Desktop on Linux likewise runs a VM and uses a separate context from a directly installed host Docker Engine. Check docker context ls if a command appears to target a different set of containers than expected.

Workstation memory deserves attention: running containers and a Linux VM can consume significant resources. Usage is workload-dependent, and WSL need not run indefinitely whenever Docker is installed. Quit or pause the relevant work before shutting down its backend. wsl --shutdown stops all running WSL distributions, so it can interrupt unrelated Linux sessions as well as Docker workloads.

Docker Desktop has separate subscription terms. The current installation page describes free personal, education, non-commercial open-source and qualifying small-business use, with paid requirements for other professional uses and government entities. Check those terms for your situation; the availability of an open-source engine is not a blanket Desktop license.

Use Cases for Docker

Here are a few scenarios where Docker can be especially useful:

Application Deployment: For deploying consistent application packages across compatible servers, with explicit configuration and data management.
Testing and Development: Run multiple versions of an application or test software in isolated environments on a workstation.
Data Science and Machine Learning: Package dependencies and environments to ensure compatibility for complex data analysis pipelines.
Microservices Architecture: Run each component of a system in a separate container for easier management, scaling, and debugging.

Summary

Docker is a powerful tool that leverages containers to run applications in isolated, lightweight environments. It’s popular both in server environments, where it simplifies deployment and scaling, and on workstations, where it helps developers manage clean environments. Docker’s flexibility, portability, and efficiency make it a valuable tool, though considerations like data persistence and security require attention.

For installation, Linux users should follow their distribution-specific Engine instructions, while workstation users should check Desktop's supported backend and licensing for their needs. Docker’s use cases range from development and testing to deploying applications and supporting microservices, making it an essential tool for modern computing.

With this guide, you’re ready to explore Docker and discover the convenience and efficiency it brings to managing applications across diverse environments.

Control WSL 2 Resources Deliberately

Microsoft documents %UserProfile%\.wslconfig for global WSL 2 VM settings. Its documented default memory allocation limit is 50% of Windows memory; that is not a promise that caches always consume that amount. The following is an example for a machine where these limits suit all the intended WSL workloads:

[wsl2]
memory=4GB
processors=4
swap=2GB

Choose values based on your workload instead of copying four gigabytes as a universal fix. This affects the WSL 2 environment, not merely one container, and does not cap all Docker Desktop processes on Windows. Swap also uses storage. Save work, stop the relevant applications and restart the WSL environment for settings to apply, recognizing that wsl --shutdown interrupts all running distributions.

A Small Compose Project and Its Lifecycle

Compose records related services and their configuration in a file. Save this stateless web-server trial as compose.yaml in a dedicated folder:

services:
  web:
    image: nginx:latest
    ports:
      - "127.0.0.1:8080:80"

Run docker compose up -d from that folder and open http://localhost:8080 on the Docker host. The left port is the host port; 80 is the container port. This loopback binding is a local learning choice, not a public deployment. A browser or another container's localhost refers to its own environment. A port-publishing rule is separate from DNS, TLS and application authentication.

Task	Compose command	What it establishes
Create/start the project	`docker compose up -d`	Starts the configured services; does not prove application health
Inspect state	`docker compose ps`	Shows service/container status
Inspect logs	`docker compose logs web`	Shows the service output; redact sensitive data before sharing
Stop temporarily	`docker compose stop`	Stops containers while retaining them
Remove this trial	`docker compose down`	Removes this project's containers/network; do not add volume-removal flags to data-bearing projects casually

This example has no durable application content. For a database or upload service, mount its documented data path to deliberate storage before using it. Back up the data consistently and test restoration; exporting an image or keeping Compose YAML does not capture the database automatically.

Pulling a newer image does not update an already running container. Review the selected release, back up persistent data and recreate the service when you intend to update it. A moving latest tag is convenient for a trial but does not identify an immutable release. Record or pin the version/digest you intend to maintain.

Keep the Container Boundaries Clear

Use trustworthy images and restrict secrets, host mounts and privileges. A writable bind mount allows the application to change that host directory. Direct Docker socket access is powerful; a container with it is not isolated from daemon administration simply because its own filesystem looks separate.

Also verify actual port exposure. Docker's documented firewall behavior can differ from ordinary host application traffic, including interaction with tools such as ufw. Do not assume that an existing host INPUT rule blocks every published container port. Check the relevant Docker networking and firewall guidance for the selected backend.

These practical distinctions preserve Docker's appeal for repeatable deployments while making its limits clear: the image packages the software, the container runs it, the storage retains its data and your deployment policy governs access, updates and recovery.