Luci4 Wiki Blog - linux:docker

installation

Anonymous (anonymous@undisclosed.example.com) — 2025-06-07T17:23:06+00:00

Chapter 1: How to Install and Use Docker on Ubuntu 22.04

Docker is a platform that enables developers to automate the deployment of applications inside lightweight, portable containers. Here's how to install and use Docker on Ubuntu Server 22.04:

Installation steps

Install the necessary packages that allow apt to use repositories over HTTPS:

sudo apt update && sudo apt install apt-transport-https \
ca-certificates curl software-properties-common

Add Docker’s official GPG key to verify the authenticity of the packages:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Add Docker’s official repository to your system’s software repository list:

echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] \
https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Update the package index again to include Docker's packages:

sudo apt update

Install Docker Engine and related components:

sudo apt install docker-ce docker-ce-cli containerd.io

Check the status of Docker to ensure it's running:

sudo systemctl status docker

You should see output indicating that Docker is active and running.

Step 2: Enable Non-Root User Access (Optional)

To allow your user to run Docker commands without sudo, add your user to the Docker group:

sudo usermod -aG docker $USER

Apply the group membership changes:

newgrp docker

Now, you can run Docker commands without sudo.

Step 3: Test Docker Installation

Run a test container to verify that Docker is working correctly:

docker run hello-world

If Docker is installed correctly, you should see a message saying “Hello from Docker!”

Chapter 2: How to Install and Use Docker Compose on Ubuntu 22.04

Docker Compose is a tool that allows you to define and manage multi-container Docker applications. Here's how to install and use Docker Compose on Ubuntu 22.04:

Step 1: Install Docker Compose Plugin

Docker Compose is now included as a plugin in Docker Engine. To install it:

sudo apt install docker-compose-plugin

Step 2: Verify Docker Compose Installation

Check the version of Docker Compose to ensure it's installed correctly:

docker compose version

You should see output indicating the version of Docker Compose installed.

Step 3: Create a Docker Compose Project

To define and run multi-container applications:

Create a project directory:

mkdir ~/myapp
cd ~/myapp

Create a docker-compose.yml file:

vim docker-compose.yml

Add the following content to define a simple web application with Nginx:

snippet.yaml

version: '3.8'
services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"

Start the application:

docker compose up -d

The -d flag runs the containers in detached mode.

Verify the running containers:

   docker ps

You should see the Nginx container listed.

Access the application:

Open a web browser and navigate to http://localhost:8080. You should see the Nginx welcome page.

Step 4: Manage Docker Compose Applications

Docker Compose provides several commands to manage your applications:

Stop the Application:

docker compose down

This stops and removes all containers defined in the docker-compose.yml file.

View Logs:

docker compose logs

This displays the logs of all containers. You can specify a service to view logs for a specific container:

docker compose logs web

Scale Services:

  docker compose up -d --scale web=3

This scales the web service to 3 instances.

View Service Status:

docker compose ps

This lists the status of all services defined in the docker-compose.yml file.

network_debug

Anonymous (anonymous@undisclosed.example.com) — 2025-06-17T18:24:50+00:00

Docker, Network Tools for Debugging

netshoot is like a network diagnostics toolbox in a container.
Great for debugging Docker networking issues without bloating your app containers.
Safe to use and easy to clean up.

The nicolaka/netshoot container is a purpose-built Docker image for network troubleshooting — it’s like a Swiss Army knife for diagnosing container network issues.

What Is netshoot?

Docker: nicolaka/netshoot
Base image: Alpine Linux (lightweight and fast)
Purpose: Gives you a fully-loaded container environment with network troubleshooting tools, ideal for debugging Docker networks, container DNS issues, firewall rules, etc.

🛠️ Tools Included (examples):

netshoot comes preloaded with tools like:

Tool	Purpose
`ping`, `traceroute`	Test basic connectivity and routing
`curl`, `wget`	Test HTTP/HTTPS endpoints
`dig`, `nslookup`	Debug DNS resolution
`netstat`, `ss`	View network sockets and connections
`tcpdump`	Capture and analyze network traffic
`iftop`, `ip`, `route`	Inspect network interfaces and routes
`nc` (netcat)	TCP/UDP connectivity testing
`nmap`	Scan for open ports and services
`iptables`, `nft`	Inspect firewall/NAT rules
`bash`, `sh`	Shell access to run custom scripts

It's ideal when your real containers are too minimal to install anything or when you're trying to debug complex networking setups in Docker, Kubernetes, or multi-container stacks.

How to Run It

To quickly start netshoot with access to your Docker bridge:

docker run --rm -it --network bridge nicolaka/netshoot

You can also attach it to a specific container's network:

docker network inspect <network_name>
docker run --rm -it --network <network_name> nicolaka/netshoot

Or, to connect to a specific container’s network namespace:

docker run --rm -it --net container:<container_name_or_id> nicolaka/netshoot

How to Remove `netshoot`

If you’ve run it with --rm (as shown above), Docker removes the container automatically when it exits — nothing to clean up.

If you want to remove the image (to reclaim disk space):

docker rmi nicolaka/netshoot

You can check if it's downloaded first:

docker images | grep netshoot

Tools included in the `nicolaka/netshoot` container, grouped by functionality so you can quickly understand what’s available and how to use it.

🧰 Network Diagnostic Tools

Tool	Purpose / Example
`ping`	Test reachability to a host (ICMP). `ping 8.8.8.8`
`traceroute`	Trace the route packets take. `traceroute google.com`
`mtr`	Combines `ping` and `traceroute` for live network path monitoring. `mtr -rw google.com`
`netcat` (`nc`)	Test TCP/UDP port availability. `nc -vz 172.17.0.1 5432`
`telnet`	Simple TCP testing (e.g., for raw HTTP or SMTP). `telnet example.com 80`
`nmap`	Port scanning and network exploration. `nmap -p 80,443 example.com`

🌐 HTTP, HTTPS, and Web Tools

Tool	Purpose / Example
`curl`	Fetch content over HTTP/HTTPS. Debug APIs. `curl -i http://localhost:8000`
`wget`	Similar to curl, useful for downloading files or testing HTTP.

📡 DNS Tools

Tool	Purpose / Example
`dig`	Perform detailed DNS lookups. `dig google.com`
`nslookup`	Simple DNS query. `nslookup google.com`
`host`	DNS lookup utility. `host google.com`

🔌 Socket and Connection Inspection

Tool	Purpose / Example
`netstat`	Show open ports and network connections. `netstat -tuln`
`ss`	Replacement for netstat (faster and more modern). `ss -lntp`
`lsof`	List open files, including network sockets. `lsof -i`

🧮 Network Interface & Traffic Monitoring

Tool	Purpose / Example
`ip`	Show IP addresses, routes, and interfaces. `ip a`, `ip r`
`route`	View or manipulate IP routing table. `route -n`
`ifconfig`	Legacy tool to view interfaces (use `ip` instead if possible).
`ethtool`	View Ethernet interface stats and features.
`iftop`	Real-time traffic usage per connection.
`nethogs`	Show bandwidth per process (like `top` but for network).
`bmon`	Bandwidth monitor (graphical console UI).

📦 Packet Sniffing & Debugging

Tool	Purpose / Example
`tcpdump`	Capture and inspect network packets. `tcpdump -i eth0 port 5432`
`wireshark`	Not in netshoot itself, but `tcpdump` can write PCAP files for Wireshark: `tcpdump -i eth0 -w /tmp/trace.pcap`

🔒 Firewall & Security

Tool	Purpose / Example
`iptables`	View and manage Linux firewall rules. `iptables -L -n -v`
`nft`	Newer firewall framework (successor to iptables). `nft list ruleset`
`ipset`	Manage IP sets for dynamic firewall rules.
`conntrack`	Track and inspect NATed connections.

🧰 Other Utilities

Tool	Purpose
`bash`, `sh`	Shell access to run scripts
`jq`	JSON processor (great for API output)
`strace`	Trace system calls from a command (e.g., see why DNS fails)
`curl`, `wget`, `ping`, `nc`	All useful in Docker and Kubernetes troubleshooting

📦 Container/Kubernetes Tools

Some versions of netshoot also include:

Tool	Purpose
`kubectl`	Interact with Kubernetes clusters
`docker`	Optional; if mounted from host, can inspect Docker from inside
`nsenter`, `ip netns`	Enter namespaces of other containers for deep inspection

🧹 Clean-Up / Exit

Just run it with --rm, and it disappears on exit:

docker run --rm -it --network bridge nicolaka/netshoot

Exit with Ctrl+D or type exit.

snippet.cpp

by:
▖     ▘▖▖
▌ ▌▌▛▘▌▙▌
▙▖▙▌▙▖▌ ▌
 
published: June 17 2025.