Portainer – Docker Container Management UI

Manage Docker Containers Visually with Portainer

Portainer simplifies Docker and Kubernetes container management through an intuitive web-based interface that makes complex containerized environments accessible to teams of all skill levels. Rather than memorizing Docker CLI commands or writing YAML manifests from scratch, administrators and developers can deploy, monitor, and manage containers through a clean graphical interface that still provides access to advanced configurations when needed.

The platform has evolved from a simple Docker UI into a comprehensive container management solution that supports Docker Standalone, Docker Swarm, Kubernetes, and Azure Container Instances. This flexibility, combined with role-based access control and audit logging, makes Portainer suitable for everything from personal home labs to enterprise production environments.

Installation

Docker Installation

Create Volume and Deploy:

docker volume create portainer_data

docker run -d -p 8000:8000 -p 9443:9443 \
  --name portainer --restart=always \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v portainer_data:/data \
  portainer/portainer-ce:latest

Access at https://localhost:9443

Docker Compose

# docker-compose.yml
version: '3.8'
services:
  portainer:
    image: portainer/portainer-ce:latest
    container_name: portainer
    restart: always
    ports:
      - "9443:9443"
      - "8000:8000"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - portainer_data:/data

volumes:
  portainer_data:

Deploy:

docker-compose up -d

Kubernetes Installation

# Using Helm
helm repo add portainer https://portainer.github.io/k8s/
helm repo update

helm upgrade --install --create-namespace -n portainer portainer portainer/portainer \
  --set service.type=LoadBalancer

Initial Setup

First Login

1. Navigate to https://localhost:9443
2. Create admin username and password
3. Accept EULA
4. Connect to your Docker environment

Environment Types

- Docker Standalone: Direct socket connection
- Docker Swarm: Cluster management
- Kubernetes: K8s cluster management
- Edge Agent: Remote environments
- Azure ACI: Azure containers

Container Management

Deploy New Container

Containers > Add Container

Configure:
- Name: my-container
- Image: nginx:latest
- Port mapping: 8080:80
- Volume mounts
- Environment variables
- Resource limits

Click "Deploy the container"

Container Operations

Actions available:
- Start/Stop/Restart
- Kill/Remove
- Pause/Unpause
- Duplicate
- Recreate
- Console access
- Logs viewing
- Inspect

Console Access

Containers > [Container] > Console

# Opens web-based terminal
# Equivalent to: docker exec -it container /bin/bash

Stack Deployments

Deploy from Compose

Stacks > Add Stack

# Paste docker-compose.yml content:
version: '3.8'
services:
  web:
    image: nginx:alpine
    ports:
      - "80:80"
  
  db:
    image: postgres:15
    environment:
      POSTGRES_PASSWORD: example
    volumes:
      - db_data:/var/lib/postgresql/data

volumes:
  db_data:

Deploy from Git Repository

Stack > Add Stack > Git Repository

Repository URL: https://github.com/user/docker-compose-project
Repository reference: refs/heads/main
Compose path: docker-compose.yml

# Supports automatic redeployment on git updates

Environment Variables

Stack > Add Stack > Advanced

Environment variables:
DATABASE_URL=postgresql://user:pass@db:5432/app
API_KEY=your-api-key
DEBUG=false

Image Management

Pull Images

Images > Pull Image

# From Docker Hub
nginx:latest

# From private registry
registry.example.com/myapp:v1.0

Build Images

Images > Build Image

Upload Dockerfile or paste content:
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
CMD ["npm", "start"]

Network Configuration

Create Network

Networks > Add Network

Name: my-network
Driver: bridge
Subnet: 172.20.0.0/16
Gateway: 172.20.0.1

Advanced options:
- Enable IPv6
- Internal network
- Attachable

Connect Container to Network

Container > Network > Join network
Select network and click "Join"

Volume Management

Create Volume

Volumes > Add Volume

Name: app-data
Driver: local

# Optional driver options
type: nfs
o: addr=192.168.1.100,rw
device: :/path/to/share

Browse Volume Contents

Volumes > [Volume] > Browse
# Graphical file browser for volume contents

User Management

Create Users

Users > Add User

Username: developer
Password: ******
Role: Standard user

Teams and Access Control

Teams > Add Team

Name: Development
Members: user1, user2

Environment access:
- Production: No access
- Staging: Read/Write

Registries

Add Private Registry

Registries > Add Registry

Type: Custom registry
Name: My Registry
URL: https://registry.example.com
Authentication: Username/Password

Docker Hub

Registries > Add Registry

Type: DockerHub
Username: your-username
Access Token: dckr_pat_xxxxx

Templates

App Templates

App Templates > Select Application

Pre-built templates for:
- Databases (MySQL, PostgreSQL, MongoDB)
- Web servers (Nginx, Apache)
- CMS (WordPress, Ghost)
- DevOps tools (Jenkins, GitLab)
- Monitoring (Grafana, Prometheus)

Custom Templates

Custom Templates > Add Template

Type: Container or Stack
Define reusable deployment configurations

API Access

Generate API Token

My Account > Access Tokens > Add Access Token

Name: automation-token
Copy token for API access

API Usage

# List containers
curl -H "X-API-Key: your-token" \
  https://portainer:9443/api/endpoints/1/docker/containers/json

# Create container via API
curl -X POST -H "X-API-Key: your-token" \
  -H "Content-Type: application/json" \
  -d '{"Image": "nginx", "name": "api-container"}' \
  https://portainer:9443/api/endpoints/1/docker/containers/create

Backup and Restore

Backup Portainer

# Backup volume
docker run --rm -v portainer_data:/data -v $(pwd):/backup \
  alpine tar czf /backup/portainer-backup.tar.gz -C /data .

Restore

docker run --rm -v portainer_data:/data -v $(pwd):/backup \
  alpine tar xzf /backup/portainer-backup.tar.gz -C /data

Portainer bridges the gap between Docker’s powerful CLI and the need for visual management, making container operations accessible while maintaining the flexibility power users expect. For teams adopting containers or managing complex deployments, Portainer provides the visibility and control needed to operate confidently in containerized environments.