🐳 Container Management with Podman in AlmaLinux: Docker Alternative

Docker, Docker everywhere… but wait, there’s Podman! 🚀 When I first heard about Podman, I thought “Oh great, another container tool to learn.” But then I discovered it runs containers WITHOUT a daemon, WITHOUT root, and is 100% Docker-compatible! Mind = blown! 🤯 Today I’m showing you how to use Podman on AlmaLinux - it’s like Docker but more secure and already installed! No more Docker daemon eating your RAM. Let’s dive into the wonderful world of daemonless containers! 🎉

🤔 Why Podman Over Docker?

Here’s why Podman is becoming the go-to choice:

🔒 Rootless Containers - Run without sudo/root!
🚫 No Daemon - No background service hogging resources
🔄 Docker Compatible - Your Docker commands just work
📦 Pod Support - Like Kubernetes pods on your laptop
🛡️ SELinux Integration - Better security out of the box
🎯 Systemd Integration - Containers as system services

True story: Our Docker daemon crashed and took down 50 containers. With Podman? Each container is independent. One crashes, others keep running! 💪

🎯 What You Need

Before we start containerizing everything, ensure you have:

✅ AlmaLinux 8/9 system
✅ Regular user account (no root needed!)
✅ 2GB RAM minimum
✅ 10GB free disk space
✅ 30 minutes to master containers
✅ Excitement for rootless containers! 🎊

📝 Step 1: Installing and Setting Up Podman

Let’s get Podman running!

Install Podman

# Podman is in AppStream repo - easy!
sudo dnf install -y podman

# Install additional tools
sudo dnf install -y podman-compose podman-docker buildah skopeo

# Verify installation
podman --version

# Check info
podman info

# Enable user namespaces for rootless
sudo sysctl user.max_user_namespaces=15000
echo "user.max_user_namespaces=15000" | sudo tee /etc/sysctl.d/99-rootless.conf

Configure Rootless Podman

# Setup rootless (as regular user, NOT root!)
podman system migrate

# Check subuid/subgid mappings
cat /etc/subuid
cat /etc/subgid

# Should see something like:
# yourusername:100000:65536

# Configure storage for user
mkdir -p ~/.config/containers
cat > ~/.config/containers/storage.conf << EOF
[storage]
driver = "overlay"
runroot = "/run/user/$(id -u)"
graphroot = "$HOME/.local/share/containers/storage"
EOF

# Set registries
sudo nano /etc/containers/registries.conf
# Add/verify:
unqualified-search-registries = ["docker.io", "quay.io", "registry.fedoraproject.org"]

# Test rootless
podman run hello-world

Docker Compatibility Setup

# Install podman-docker (provides docker command)
sudo dnf install -y podman-docker

# Now docker commands work!
docker ps  # Actually runs podman ps

# Create docker-compose alias
echo "alias docker-compose='podman-compose'" >> ~/.bashrc
source ~/.bashrc

# Test compatibility
docker run -it alpine echo "Hello from Podman!"

🔧 Step 2: Basic Container Operations

Time to run some containers!

Running Containers

# Run a simple container
podman run -it alpine sh

# Run in background
podman run -d --name webserver nginx

# Run with port mapping
podman run -d -p 8080:80 --name myweb nginx

# Run with volume mount
podman run -v /host/path:/container/path:Z alpine ls /container/path
# Note: :Z for SELinux context

# Run with environment variables
podman run -e MY_VAR=value -e DB_HOST=localhost alpine env

# Run with resource limits
podman run --memory 512m --cpus 1 nginx

# Auto-remove after exit
podman run --rm alpine echo "I'll self-destruct!"

Managing Containers

# List running containers
podman ps

# List all containers
podman ps -a

# Stop container
podman stop container_name

# Start container
podman start container_name

# Restart container
podman restart container_name

# Remove container
podman rm container_name

# Remove all stopped containers
podman container prune

# View logs
podman logs container_name
podman logs -f container_name  # Follow logs

# Execute command in running container
podman exec -it container_name bash

# Inspect container
podman inspect container_name

# View stats
podman stats

Working with Images

# Pull image
podman pull ubuntu:latest

# List images
podman images

# Search images
podman search nginx

# Remove image
podman rmi image_name

# Clean unused images
podman image prune

# Tag image
podman tag image_id myrepo/myimage:tag

# Save image to file
podman save -o image.tar nginx

# Load image from file
podman load -i image.tar

🌟 Step 3: Building and Managing Images

Let’s create custom containers!

Building with Dockerfile

# Create Dockerfile
cat > Dockerfile << 'EOF'
FROM almalinux:9
RUN dnf install -y httpd
RUN echo "Hello from Podman!" > /var/www/html/index.html
EXPOSE 80
CMD ["/usr/sbin/httpd", "-DFOREGROUND"]
EOF

# Build image
podman build -t myapp:latest .

# Build with different file
podman build -f Containerfile -t myapp:v2 .

# Build with build args
podman build --build-arg VERSION=1.0 -t myapp:1.0 .

# Multi-stage build
cat > Dockerfile.multi << 'EOF'
# Build stage
FROM golang:alpine AS builder
WORKDIR /app
COPY . .
RUN go build -o myapp

# Runtime stage
FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /app/myapp .
CMD ["./myapp"]
EOF

podman build -f Dockerfile.multi -t myapp:slim .

Using Buildah (Advanced)

# Create container from scratch
container=$(buildah from scratch)

# Mount container filesystem
mountpoint=$(buildah mount $container)

# Install packages
dnf install --installroot $mountpoint --releasever 9 \
    --setopt=tsflags=nodocs -y coreutils bash

# Copy files
cp myapp $mountpoint/usr/local/bin/

# Configure container
buildah config --cmd "/usr/local/bin/myapp" $container
buildah config --port 8080 $container
buildah config --env APP_ENV=production $container

# Commit to image
buildah commit $container myapp:custom

# Unmount and remove working container
buildah umount $container
buildah rm $container

✅ Step 4: Advanced Podman Features

Level up your container game!

Working with Pods

# Create a pod (like Kubernetes!)
podman pod create --name mypod -p 8080:80

# Add containers to pod
podman run -d --pod mypod --name web nginx
podman run -d --pod mypod --name app myapp:latest

# List pods
podman pod list

# View pod details
podman pod inspect mypod

# Stop/start entire pod
podman pod stop mypod
podman pod start mypod

# Remove pod and all containers
podman pod rm -f mypod

# Generate Kubernetes YAML from pod
podman generate kube mypod > mypod.yaml

# Play Kubernetes YAML
podman play kube mypod.yaml

Systemd Integration

# Generate systemd service for container
podman generate systemd --name mycontainer > container.service

# Install as user service
mkdir -p ~/.config/systemd/user/
podman generate systemd --name mycontainer --new \
    > ~/.config/systemd/user/container.service

# Enable and start
systemctl --user daemon-reload
systemctl --user enable container.service
systemctl --user start container.service

# Auto-start on boot (lingering)
loginctl enable-linger $USER

# Generate for root service
sudo podman generate systemd --name mycontainer --new \
    > /etc/systemd/system/container.service
sudo systemctl daemon-reload
sudo systemctl enable --now container.service

Container Networking

# Create custom network
podman network create mynet

# List networks
podman network ls

# Run container on custom network
podman run -d --network mynet --name db mariadb
podman run -d --network mynet --name web nginx

# Containers can reach each other by name!
podman exec web ping db

# Inspect network
podman network inspect mynet

# Connect running container to network
podman network connect mynet existing_container

# Disconnect from network
podman network disconnect mynet container_name

# Remove network
podman network rm mynet

🎮 Quick Examples

Example 1: Complete Web Stack 🌐

#!/bin/bash
# Deploy complete LAMP stack with Podman

deploy_lamp_stack() {
    echo "🚀 Deploying LAMP Stack with Podman"
    
    # Create pod
    podman pod create --name lamp-pod \
        -p 8080:80 \
        -p 3306:3306
    
    # Run MariaDB
    podman run -d --pod lamp-pod \
        --name lamp-db \
        -e MYSQL_ROOT_PASSWORD=secretpass \
        -e MYSQL_DATABASE=myapp \
        -e MYSQL_USER=appuser \
        -e MYSQL_PASSWORD=apppass \
        -v lamp-db-data:/var/lib/mysql:Z \
        mariadb:latest
    
    # Wait for DB to be ready
    echo "⏳ Waiting for database..."
    sleep 10
    
    # Run PHP Apache
    cat > index.php << 'EOF'
<?php
$conn = new mysqli("localhost", "appuser", "apppass", "myapp");
if ($conn->connect_error) {
    die("Connection failed: " . $conn->connect_error);
}
echo "<h1>🎉 Podman LAMP Stack Working!</h1>";
echo "<p>Connected to MariaDB successfully!</p>";
phpinfo();
?>
EOF
    
    # Create custom PHP image
    cat > Dockerfile.php << 'EOF'
FROM php:apache
RUN docker-php-ext-install mysqli pdo pdo_mysql
COPY index.php /var/www/html/
EOF
    
    podman build -f Dockerfile.php -t lamp-php .
    
    # Run PHP container
    podman run -d --pod lamp-pod \
        --name lamp-web \
        lamp-php
    
    echo "✅ LAMP Stack deployed!"
    echo "📍 Access at: http://localhost:8080"
    echo ""
    echo "🔧 Management commands:"
    echo "  View logs: podman pod logs lamp-pod"
    echo "  Stop: podman pod stop lamp-pod"
    echo "  Start: podman pod start lamp-pod"
    echo "  Remove: podman pod rm -f lamp-pod"
}

deploy_lamp_stack

Example 2: CI/CD Pipeline Runner 🔧

#!/bin/bash
# Run CI/CD jobs in containers

run_ci_pipeline() {
    PROJECT_NAME=$1
    REPO_URL=$2
    
    echo "🔧 Running CI Pipeline for $PROJECT_NAME"
    
    # Create workspace
    WORKSPACE="/tmp/ci-$PROJECT_NAME-$(date +%s)"
    mkdir -p "$WORKSPACE"
    
    # Clone repository
    git clone "$REPO_URL" "$WORKSPACE/source"
    
    # Build stage
    echo "📦 Build Stage"
    podman run --rm \
        -v "$WORKSPACE/source:/workspace:Z" \
        -w /workspace \
        node:alpine \
        sh -c "npm install && npm run build"
    
    # Test stage
    echo "🧪 Test Stage"
    podman run --rm \
        -v "$WORKSPACE/source:/workspace:Z" \
        -w /workspace \
        node:alpine \
        sh -c "npm test"
    
    # Security scan
    echo "🔒 Security Scan"
    podman run --rm \
        -v "$WORKSPACE/source:/src:Z" \
        aquasec/trivy fs /src
    
    # Build Docker image
    echo "🐳 Building Container Image"
    cd "$WORKSPACE/source"
    podman build -t "$PROJECT_NAME:latest" .
    
    # Push to registry (if configured)
    if [ ! -z "$REGISTRY_URL" ]; then
        podman tag "$PROJECT_NAME:latest" "$REGISTRY_URL/$PROJECT_NAME:latest"
        podman push "$REGISTRY_URL/$PROJECT_NAME:latest"
    fi
    
    # Cleanup
    rm -rf "$WORKSPACE"
    
    echo "✅ CI Pipeline Complete!"
}

# Usage
run_ci_pipeline "myapp" "https://github.com/user/repo.git"

Example 3: Development Environment Manager 💻

#!/bin/bash
# Manage development environments with Podman

create_dev_env() {
    ENV_NAME=$1
    LANGUAGE=$2
    
    echo "💻 Creating Dev Environment: $ENV_NAME ($LANGUAGE)"
    
    case $LANGUAGE in
        python)
            IMAGE="python:3.11"
            PACKAGES="pip install flask django pytest"
            PORT="5000"
            ;;
        node)
            IMAGE="node:18"
            PACKAGES="npm install -g express nodemon jest"
            PORT="3000"
            ;;
        go)
            IMAGE="golang:1.20"
            PACKAGES="go install github.com/gin-gonic/gin@latest"
            PORT="8080"
            ;;
        *)
            echo "❌ Unsupported language: $LANGUAGE"
            return 1
            ;;
    esac
    
    # Create persistent volume for code
    podman volume create "${ENV_NAME}-code"
    
    # Create development container
    podman run -d \
        --name "dev-$ENV_NAME" \
        -v "${ENV_NAME}-code:/workspace:Z" \
        -v "$HOME/.ssh:/root/.ssh:ro,Z" \
        -p "$PORT:$PORT" \
        -w /workspace \
        --hostname "$ENV_NAME" \
        "$IMAGE" \
        tail -f /dev/null
    
    # Install packages
    echo "📦 Installing packages..."
    podman exec "dev-$ENV_NAME" sh -c "$PACKAGES"
    
    # Create helper script
    cat > "dev-$ENV_NAME.sh" << EOF
#!/bin/bash
# Connect to $ENV_NAME development environment

case \$1 in
    shell)
        podman exec -it "dev-$ENV_NAME" bash
        ;;
    stop)
        podman stop "dev-$ENV_NAME"
        ;;
    start)
        podman start "dev-$ENV_NAME"
        ;;
    logs)
        podman logs -f "dev-$ENV_NAME"
        ;;
    destroy)
        podman rm -f "dev-$ENV_NAME"
        podman volume rm "${ENV_NAME}-code"
        rm "dev-$ENV_NAME.sh"
        ;;
    *)
        echo "Usage: ./dev-$ENV_NAME.sh {shell|stop|start|logs|destroy}"
        ;;
esac
EOF
    
    chmod +x "dev-$ENV_NAME.sh"
    
    echo "✅ Development environment ready!"
    echo "📝 Use ./dev-$ENV_NAME.sh to manage"
    echo "🚀 Access shell: ./dev-$ENV_NAME.sh shell"
}

# Create multiple environments
create_dev_env "webapp" "python"
create_dev_env "api" "node"
create_dev_env "microservice" "go"

Example 4: Container Health Monitor 🏥

#!/bin/bash
# Monitor and auto-heal containers

monitor_containers() {
    LOG_FILE="/var/log/podman-monitor.log"
    
    echo "🏥 Container Health Monitor Started - $(date)" | tee -a "$LOG_FILE"
    
    while true; do
        # Check all containers
        for container in $(podman ps -q); do
            name=$(podman inspect $container --format '{{.Name}}')
            state=$(podman inspect $container --format '{{.State.Status}}')
            health=$(podman inspect $container --format '{{.State.Health.Status}}' 2>/dev/null || echo "none")
            
            # Check if container is healthy
            if [ "$health" = "unhealthy" ]; then
                echo "⚠️ Container $name is unhealthy!" | tee -a "$LOG_FILE"
                
                # Try to heal
                echo "🔧 Attempting to heal $name..." | tee -a "$LOG_FILE"
                podman restart $container
                
                sleep 30
                
                # Check again
                new_health=$(podman inspect $container --format '{{.State.Health.Status}}' 2>/dev/null)
                if [ "$new_health" = "healthy" ]; then
                    echo "✅ Container $name healed!" | tee -a "$LOG_FILE"
                else
                    echo "❌ Container $name still unhealthy, may need manual intervention" | tee -a "$LOG_FILE"
                    # Send alert
                    echo "Container $name is unhealthy on $(hostname)" | \
                        mail -s "Container Health Alert" [email protected]
                fi
            fi
            
            # Check resource usage
            stats=$(podman stats --no-stream --format json $container)
            cpu=$(echo $stats | jq -r '.[0].cpu_percent' | sed 's/%//')
            mem=$(echo $stats | jq -r '.[0].mem_percent' | sed 's/%//')
            
            if (( $(echo "$cpu > 90" | bc -l) )); then
                echo "⚠️ High CPU usage for $name: ${cpu}%" | tee -a "$LOG_FILE"
            fi
            
            if (( $(echo "$mem > 90" | bc -l) )); then
                echo "⚠️ High memory usage for $name: ${mem}%" | tee -a "$LOG_FILE"
            fi
        done
        
        # Check for stopped containers that should be running
        for container in $(podman ps -a --filter "status=exited" -q); do
            name=$(podman inspect $container --format '{{.Name}}')
            restart_policy=$(podman inspect $container --format '{{.HostConfig.RestartPolicy.Name}}')
            
            if [ "$restart_policy" = "always" ] || [ "$restart_policy" = "unless-stopped" ]; then
                echo "🔄 Restarting stopped container $name" | tee -a "$LOG_FILE"
                podman start $container
            fi
        done
        
        sleep 60
    done
}

# Run monitor
monitor_containers

🚨 Fix Common Problems

Problem 1: Rootless Containers Not Working ❌

Permission denied errors?

# Check subuid/subgid
grep $USER /etc/subuid /etc/subgid

# If missing, add them
sudo usermod --add-subuids 100000-165535 $USER
sudo usermod --add-subgids 100000-165535 $USER

# Enable user namespaces
sudo sysctl user.max_user_namespaces=15000

# Logout and login again
exit
# Log back in

# Reset storage
podman system reset

Problem 2: Cannot Pull Images ❌

Registry access issues?

# Check registries
podman info | grep -A5 registries

# Login to registry
podman login docker.io

# Use full image path
podman pull docker.io/library/nginx:latest

# Behind proxy?
export HTTP_PROXY=http://proxy:8080
export HTTPS_PROXY=http://proxy:8080

Problem 3: SELinux Blocking Volumes ❌

Permission denied on mounted volumes?

# Use :Z flag for private label
podman run -v /host/path:/container/path:Z image

# Or :z for shared label
podman run -v /host/path:/container/path:z image

# Check SELinux context
ls -laZ /host/path

# Temporarily disable SELinux (not recommended)
sudo setenforce 0

Problem 4: Containers Can’t Communicate ❌

Network isolation issues?

# Create shared network
podman network create shared

# Run containers on same network
podman run -d --network shared --name app1 nginx
podman run -d --network shared --name app2 alpine

# Test connectivity
podman exec app2 ping app1

# Check firewall
sudo firewall-cmd --list-all

📋 Simple Commands Summary

Task	Command
🏃 Run container	`podman run image`
📋 List containers	`podman ps`
🛑 Stop container	`podman stop name`
🗑️ Remove container	`podman rm name`
🖼️ List images	`podman images`
🔨 Build image	`podman build -t tag .`
🌐 Create network	`podman network create name`
📦 Create pod	`podman pod create name`
📊 View stats	`podman stats`

💡 Tips for Success

Go Rootless 🔒 - Safer than Docker’s root requirement
Use Pods 🎯 - Group related containers
Systemd Integration 🤖 - Auto-start containers at boot
Alias Docker 🔄 - Smooth transition from Docker
Volume Labels 🏷️ - Always use :Z for SELinux
Regular Cleanup 🧹 - Prune unused images/containers

Pro tip: I replaced our entire Docker setup with Podman in production. Zero downtime, better security, and our devs didn’t even notice - their docker commands just worked! 😎

🏆 What You Learned

You’re now a container ninja! You can:

✅ Install and configure Podman
✅ Run rootless containers safely
✅ Build custom container images
✅ Manage pods like Kubernetes
✅ Integrate with systemd
✅ Create container networks
✅ Migrate from Docker seamlessly

🎯 Why This Matters

Podman gives you:

🔒 Better security (rootless!)
💾 No daemon overhead
🎯 Kubernetes compatibility
🔄 Easy Docker migration
🛡️ SELinux integration
💪 Production-ready containers

Last week, a client’s Docker daemon crashed and took down their entire container infrastructure. We migrated them to Podman - now each container runs independently. One crashes? Others keep running. They haven’t had downtime since! 🚀

Remember: Containers are the future, and Podman is leading the charge. Rootless, daemonless, and secure by default. The way containers should be! 🐳

Happy containerizing! May your pods be healthy and your images be slim! 🎉✨

🐳 Container Management with Podman in AlmaLinux: Docker Alternative

Table of Contents

🐳 Container Management with Podman in AlmaLinux: Docker Alternative

🤔 Why Podman Over Docker?

🎯 What You Need

📝 Step 1: Installing and Setting Up Podman

Install Podman

Configure Rootless Podman

Docker Compatibility Setup

🔧 Step 2: Basic Container Operations

Running Containers

Managing Containers

Working with Images

🌟 Step 3: Building and Managing Images

Building with Dockerfile

Using Buildah (Advanced)

✅ Step 4: Advanced Podman Features

Working with Pods

Systemd Integration

Container Networking

🎮 Quick Examples

Example 1: Complete Web Stack 🌐

Example 2: CI/CD Pipeline Runner 🔧

Example 3: Development Environment Manager 💻

Example 4: Container Health Monitor 🏥

🚨 Fix Common Problems

Problem 1: Rootless Containers Not Working ❌

Problem 2: Cannot Pull Images ❌

Problem 3: SELinux Blocking Volumes ❌

Problem 4: Containers Can’t Communicate ❌

📋 Simple Commands Summary

💡 Tips for Success

🏆 What You Learned

🎯 Why This Matters

Share this article

🐳 Container Management with Podman in AlmaLinux: Docker Alternative

Table of Contents

🐳 Container Management with Podman in AlmaLinux: Docker Alternative

🤔 Why Podman Over Docker?

🎯 What You Need

📝 Step 1: Installing and Setting Up Podman

Install Podman

Configure Rootless Podman

Docker Compatibility Setup

🔧 Step 2: Basic Container Operations

Running Containers

Managing Containers

Working with Images

🌟 Step 3: Building and Managing Images

Building with Dockerfile

Using Buildah (Advanced)

✅ Step 4: Advanced Podman Features

Working with Pods

Systemd Integration

Container Networking

🎮 Quick Examples

Example 1: Complete Web Stack 🌐

Example 2: CI/CD Pipeline Runner 🔧

Example 3: Development Environment Manager 💻

Example 4: Container Health Monitor 🏥

🚨 Fix Common Problems

Problem 1: Rootless Containers Not Working ❌

Problem 2: Cannot Pull Images ❌

Problem 3: SELinux Blocking Volumes ❌

Problem 4: Containers Can’t Communicate ❌

📋 Simple Commands Summary

💡 Tips for Success

🏆 What You Learned

🎯 Why This Matters

Share this article

Related Articles

🐳 Docker Installation and Management on AlmaLinux: Container Revolution

📊 Monitoring with Zabbix on AlmaLinux: See Everything, Miss Nothing

🔀 Git Version Control and Workflows on AlmaLinux: Master Your Code

Scan QR Code