Podman Bare Metal Performance Analysis: Complete Guide#

1
#!/bin/bash
2
# podman-performance-benchmark.sh - Comprehensive Podman performance testing
3

4
set -euo pipefail
5

6
# Configuration
7
TEST_IMAGE="registry.fedoraproject.org/fedora:38"
8
WORKLOAD_IMAGE="nginx:alpine"
9
ITERATIONS=100
10
RESULTS_DIR="./podman-benchmarks-$(date +%Y%m%d-%H%M%S)"
11

12
mkdir -p "$RESULTS_DIR"
13

14
echo "=== Podman Bare Metal Performance Benchmark Suite ===" | tee "$RESULTS_DIR/summary.log"
15
echo "Date: $(date)" | tee -a "$RESULTS_DIR/summary.log"
16
echo "Host: $(hostname)" | tee -a "$RESULTS_DIR/summary.log"
17
echo "Kernel: $(uname -r)" | tee -a "$RESULTS_DIR/summary.log"
18
echo "Podman Version: $(podman version --format '{{.Client.Version}}')" | tee -a "$RESULTS_DIR/summary.log"
19

20
# Function to measure container startup time
21
measure_startup_time() {
22
    local image=$1
23
    local iterations=$2
24
    local test_name=$3
25

26
    echo "Running $test_name startup benchmark..." | tee -a "$RESULTS_DIR/summary.log"
27

28
    local startup_times=()
29
    for ((i=1; i<=iterations; i++)); do
30
        local start_time=$(date +%s.%N)
31
        podman run --rm "$image" echo "test" >/dev/null 2>&1
32
        local end_time=$(date +%s.%N)
33
        local duration=$(echo "$end_time - $start_time" | bc)
34
        startup_times+=("$duration")
35

36
        if ((i % 10 == 0)); then
37
            echo "  Completed $i/$iterations iterations"
38
        fi
39
    done
40

41
    # Calculate statistics
42
    local sum=0
43
    local min=${startup_times[0]}
44
    local max=${startup_times[0]}
45

46
    for time in "${startup_times[@]}"; do
47
        sum=$(echo "$sum + $time" | bc)
48
        if (($(echo "$time < $min" | bc -l))); then
49
            min=$time
50
        fi
51
        if (($(echo "$time > $max" | bc -l))); then
52
            max=$time
53
        fi
54
    done
55

56
    local avg=$(echo "scale=3; $sum / $iterations" | bc)
57

58
    echo "$test_name Results:" | tee -a "$RESULTS_DIR/startup-$test_name.log"
59
    echo "  Average: ${avg}s" | tee -a "$RESULTS_DIR/startup-$test_name.log"
60
    echo "  Minimum: ${min}s" | tee -a "$RESULTS_DIR/startup-$test_name.log"
61
    echo "  Maximum: ${max}s" | tee -a "$RESULTS_DIR/startup-$test_name.log"
62

63
    # Save raw data
64
    printf "%s\n" "${startup_times[@]}" > "$RESULTS_DIR/raw-startup-$test_name.dat"
65
}
66

67
# Function to measure memory overhead
68
measure_memory_overhead() {
69
    echo "Measuring memory overhead..." | tee -a "$RESULTS_DIR/summary.log"
70

71
    # Baseline memory usage
72
    local baseline_memory=$(free -m | awk '/^Mem:/ {print $3}')
73

74
    # Start containers and measure memory
75
    local container_count=50
76
    local containers=()
77

78
    for ((i=1; i<=container_count; i++)); do
79
        local container_id=$(podman run -d --rm "$WORKLOAD_IMAGE" sleep 300)
80
        containers+=("$container_id")
81

82
        if ((i % 10 == 0)); then
83
            local current_memory=$(free -m | awk '/^Mem:/ {print $3}')
84
            local overhead=$((current_memory - baseline_memory))
85
            echo "  $i containers: ${overhead}MB overhead" | tee -a "$RESULTS_DIR/memory-overhead.log"
86
        fi
87
    done
88

89
    # Cleanup
90
    for container in "${containers[@]}"; do
91
        podman stop "$container" >/dev/null 2>&1 || true
92
    done
93

94
    echo "Memory overhead test completed" | tee -a "$RESULTS_DIR/summary.log"
95
}
96

97
# Function to measure I/O performance
98
measure_io_performance() {
99
    echo "Measuring I/O performance..." | tee -a "$RESULTS_DIR/summary.log"
100

101
    # Sequential write test
102
    echo "  Testing sequential write performance..."
103
    podman run --rm -v "$RESULTS_DIR:/benchmark" "$TEST_IMAGE" \
104
        bash -c "dd if=/dev/zero of=/benchmark/test-write bs=1M count=1000 2>&1 | grep 'bytes transferred'" \
105
        | tee -a "$RESULTS_DIR/io-performance.log"
106

107
    # Sequential read test
108
    echo "  Testing sequential read performance..."
109
    podman run --rm -v "$RESULTS_DIR:/benchmark" "$TEST_IMAGE" \
110
        bash -c "dd if=/benchmark/test-write of=/dev/null bs=1M 2>&1 | grep 'bytes transferred'" \
111
        | tee -a "$RESULTS_DIR/io-performance.log"
112

113
    # Random I/O test with fio
114
    echo "  Testing random I/O performance..."
115
    podman run --rm -v "$RESULTS_DIR:/benchmark" quay.io/jitesoft/fio \
116
        fio --name=random-rw --ioengine=libaio --iodepth=32 --rw=randrw \
117
        --bs=4k --direct=1 --size=1G --numjobs=4 --runtime=60 \
118
        --group_reporting --filename=/benchmark/fio-test \
119
        | tee -a "$RESULTS_DIR/io-performance.log"
120

121
    # Cleanup
122
    rm -f "$RESULTS_DIR/test-write" "$RESULTS_DIR/fio-test"
123
}
124

125
# Function to measure network performance
126
measure_network_performance() {
127
    echo "Measuring network performance..." | tee -a "$RESULTS_DIR/summary.log"
128

129
    # Create a test network
130
    podman network create benchmark-net
131

132
    # Start iperf3 server
133
    local server_id=$(podman run -d --name iperf-server --network benchmark-net \
134
        quay.io/jitesoft/iperf3 iperf3 -s)
135

136
    sleep 5
137

138
    # Run client tests
139
    echo "  Testing TCP throughput..."
140
    podman run --rm --network benchmark-net quay.io/jitesoft/iperf3 \
141
        iperf3 -c iperf-server -t 30 -P 4 | tee -a "$RESULTS_DIR/network-performance.log"
142

143
    echo "  Testing UDP throughput..."
144
    podman run --rm --network benchmark-net quay.io/jitesoft/iperf3 \
145
        iperf3 -c iperf-server -u -b 1G -t 30 | tee -a "$RESULTS_DIR/network-performance.log"
146

147
    # Cleanup
148
    podman stop iperf-server >/dev/null 2>&1 || true
149
    podman rm iperf-server >/dev/null 2>&1 || true
150
    podman network rm benchmark-net >/dev/null 2>&1 || true
151
}
152

153
# Pre-pull images
154
echo "Pre-pulling test images..." | tee -a "$RESULTS_DIR/summary.log"
155
podman pull "$TEST_IMAGE" >/dev/null 2>&1
156
podman pull "$WORKLOAD_IMAGE" >/dev/null 2>&1
157
podman pull quay.io/jitesoft/fio >/dev/null 2>&1
158
podman pull quay.io/jitesoft/iperf3 >/dev/null 2>&1
159

160
# Run benchmarks
161
measure_startup_time "$TEST_IMAGE" 50 "basic-container"
162
measure_startup_time "$WORKLOAD_IMAGE" 30 "nginx-container"
163
measure_memory_overhead
164
measure_io_performance
165
measure_network_performance
166

167
# Generate summary
168
echo "=== Benchmark Summary ===" | tee -a "$RESULTS_DIR/summary.log"
169
echo "Results saved to: $RESULTS_DIR" | tee -a "$RESULTS_DIR/summary.log"
170
echo "Benchmark completed at: $(date)" | tee -a "$RESULTS_DIR/summary.log"
171

172
echo "Podman performance benchmark completed successfully!"

1
#!/bin/bash
2
# podman-resource-profiling.sh - Detailed resource utilization analysis
3

4
# Function to profile CPU usage during container operations
5
profile_cpu_usage() {
6
    local test_name=$1
7
    local duration=$2
8

9
    echo "Profiling CPU usage for $test_name..."
10

11
    # Start system monitoring
12
    pidstat -u 1 $duration > "cpu-profile-$test_name.log" &
13
    local pidstat_pid=$!
14

15
    # Start container workload
16
    case $test_name in
17
        "startup-intensive")
18
            for ((i=1; i<=20; i++)); do
19
                podman run --rm registry.fedoraproject.org/fedora:38 \
20
                    bash -c "stress --cpu 4 --timeout 10s" &
21
            done
22
            wait
23
            ;;
24
        "memory-intensive")
25
            podman run --rm --memory=2g registry.fedoraproject.org/fedora:38 \
26
                bash -c "stress --vm 2 --vm-bytes 1G --timeout ${duration}s"
27
            ;;
28
        "io-intensive")
29
            podman run --rm -v "$(pwd):/workdir" registry.fedoraproject.org/fedora:38 \
30
                bash -c "dd if=/dev/zero of=/workdir/test bs=1M count=1000; rm /workdir/test"
31
            ;;
32
    esac
33

34
    # Stop monitoring
35
    kill $pidstat_pid 2>/dev/null || true
36
    wait $pidstat_pid 2>/dev/null || true
37
}
38

39
# Function to analyze memory patterns
40
analyze_memory_patterns() {
41
    echo "Analyzing memory usage patterns..."
42

43
    # Monitor memory during container lifecycle
44
    for operation in "pull" "create" "start" "stop" "rm"; do
45
        echo "Memory usage during: $operation"
46

47
        case $operation in
48
            "pull")
49
                free -m > "memory-before-$operation.log"
50
                podman pull registry.redhat.io/ubi8/ubi:latest >/dev/null 2>&1
51
                free -m > "memory-after-$operation.log"
52
                ;;
53
            "create")
54
                free -m > "memory-before-$operation.log"
55
                local container_id=$(podman create nginx:alpine)
56
                free -m > "memory-after-$operation.log"
57
                ;;
58
            "start")
59
                free -m > "memory-before-$operation.log"
60
                podman start $container_id >/dev/null 2>&1
61
                free -m > "memory-after-$operation.log"
62
                ;;
63
            "stop")
64
                free -m > "memory-before-$operation.log"
65
                podman stop $container_id >/dev/null 2>&1
66
                free -m > "memory-after-$operation.log"
67
                ;;
68
            "rm")
69
                free -m > "memory-before-$operation.log"
70
                podman rm $container_id >/dev/null 2>&1
71
                free -m > "memory-after-$operation.log"
72
                ;;
73
        esac
74

75
        # Calculate memory difference
76
        local before=$(grep "^Mem:" "memory-before-$operation.log" | awk '{print $3}')
77
        local after=$(grep "^Mem:" "memory-after-$operation.log" | awk '{print $3}')
78
        local diff=$((after - before))
79
        echo "  Memory change: ${diff}MB"
80
    done
81
}
82

83
# System information collection
84
collect_system_info() {
85
    echo "=== System Information ===" > system-info.log
86
    echo "Date: $(date)" >> system-info.log
87
    echo "Hostname: $(hostname)" >> system-info.log
88
    echo "Uptime: $(uptime)" >> system-info.log
89
    echo "" >> system-info.log
90

91
    echo "=== Hardware Information ===" >> system-info.log
92
    lscpu >> system-info.log
93
    echo "" >> system-info.log
94
    cat /proc/meminfo >> system-info.log
95
    echo "" >> system-info.log
96

97
    echo "=== Storage Information ===" >> system-info.log
98
    df -h >> system-info.log
99
    echo "" >> system-info.log
100
    lsblk >> system-info.log
101
    echo "" >> system-info.log
102

103
    echo "=== Container Runtime Information ===" >> system-info.log
104
    podman info >> system-info.log
105
    echo "" >> system-info.log
106
    podman system df >> system-info.log
107
}
108

109
# Run profiling
110
collect_system_info
111
profile_cpu_usage "startup-intensive" 60
112
profile_cpu_usage "memory-intensive" 120
113
profile_cpu_usage "io-intensive" 90
114
analyze_memory_patterns
115

116
echo "Resource profiling completed!"

1
#!/bin/bash
2
# storage-optimization.sh - Optimize storage for Podman
3

4
# Configure optimal storage driver
5
configure_storage_driver() {
6
    local storage_conf="/etc/containers/storage.conf"
7

8
    # Backup original configuration
9
    cp "$storage_conf" "${storage_conf}.backup"
10

11
    # Configure overlay2 with optimizations
12
    cat > "$storage_conf" << EOF
13
[storage]
14
driver = "overlay"
15
runroot = "/run/containers/storage"
16
graphroot = "/var/lib/containers/storage"
17

18
[storage.options]
19
additionalimagestores = []
20

21
[storage.options.overlay]
22
mountopt = "nodev,metacopy=on"
23
size = ""
24
skip_mount_home = "false"
25
mount_program = "/usr/bin/fuse-overlayfs"
26

27
[storage.options.thinpool]
28
autoextend_percent = "20"
29
autoextend_threshold = "80"
30
basesize = "10G"
31
blocksize = "64k"
32
directlvm_device = ""
33
directlvm_device_force = "True"
34
fs = "xfs"
35
log_level = "7"
36
min_free_space = "10%"
37
mkfsarg = ""
38
size = ""
39
use_deferred_deletion = "True"
40
use_deferred_removal = "True"
41
xfs_nospace_max_retries = "0"
42
EOF
43

44
    echo "Storage configuration optimized"
45
}
46

47
# Optimize XFS filesystem for containers
48
optimize_xfs_filesystem() {
49
    local mount_point="/var/lib/containers"
50

51
    if df -T "$mount_point" | grep -q xfs; then
52
        echo "Configuring XFS optimizations..."
53

54
        # Add to /etc/fstab for persistent mount options
55
        local device=$(df "$mount_point" | tail -1 | awk '{print $1}')
56
        local uuid=$(blkid -s UUID -o value "$device")
57

58
        # XFS mount options for container workloads
59
        local mount_opts="rw,noatime,attr2,inode64,logbufs=8,logbsize=32k,noquota"
60

61
        echo "UUID=$uuid $mount_point xfs $mount_opts 0 2" >> /etc/fstab
62
        echo "XFS optimization configured. Reboot required for full effect."
63
    fi
64
}
65

66
# Configure container image caching
67
setup_image_caching() {
68
    # Create systemd service for image warming
69
    cat > /etc/systemd/system/podman-image-warming.service << EOF
70
[Unit]
71
Description=Podman Image Warming Service
72
After=network-online.target
73
Wants=network-online.target
74

75
[Service]
76
Type=oneshot
77
ExecStart=/usr/local/bin/warm-podman-images.sh
78
RemainAfterExit=yes
79

80
[Install]
81
WantedBy=multi-user.target
82
EOF
83

84
    # Create image warming script
85
    cat > /usr/local/bin/warm-podman-images.sh << 'EOF'
86
#!/bin/bash
87
# Warm commonly used images
88

89
COMMON_IMAGES=(
90
    "registry.fedoraproject.org/fedora:38"
91
    "registry.redhat.io/ubi8/ubi:latest"
92
    "nginx:alpine"
93
    "redis:alpine"
94
    "postgres:alpine"
95
)
96

97
for image in "${COMMON_IMAGES[@]}"; do
98
    echo "Warming image: $image"
99
    podman pull "$image" || echo "Failed to pull $image"
100
done
101

102
echo "Image warming completed"
103
EOF
104

105
    chmod +x /usr/local/bin/warm-podman-images.sh
106
    systemctl enable podman-image-warming.service
107
}
108

109
configure_storage_driver
110
optimize_xfs_filesystem
111
setup_image_caching
112

113
echo "Storage optimization completed!"

1
#!/bin/bash
2
# podman-tuning.sh - Optimize Podman runtime configuration
3

4
# Function to optimize containers.conf
5
optimize_containers_conf() {
6
    local conf_file="/etc/containers/containers.conf"
7

8
    # Backup original configuration
9
    cp "$conf_file" "${conf_file}.backup" 2>/dev/null || true
10

11
    cat > "$conf_file" << EOF
12
[containers]
13
# Networking optimizations
14
default_sysctls = [
15
    "net.ipv4.ping_group_range=0 0",
16
    "net.ipv4.ip_unprivileged_port_start=80"
17
]
18

19
# Resource limits
20
default_ulimits = [
21
    "nofile=65536:65536",
22
    "nproc=8192:8192"
23
]
24

25
# Performance tuning
26
log_size_max = 10485760
27
pids_limit = 4096
28
shm_size = "256m"
29

30
# Security with performance balance
31
seccomp_profile = "/usr/share/containers/seccomp.json"
32
apparmor_profile = "containers-default-0.50.0"
33

34
[engine]
35
# Event logging optimization
36
events_logger = "journald"
37

38
# Image handling
39
image_default_transport = "docker://"
40
image_parallel_copies = 4
41

42
# Network configuration
43
network_backend = "netavark"
44
network_config_dir = "/etc/containers/networks"
45

46
# Runtime optimization
47
runtime = "crun"
48
static_dir = "/var/lib/containers/storage/libpod"
49
tmp_dir = "/var/tmp"
50

51
# Volume handling
52
volume_path = "/var/lib/containers/storage/volumes"
53

54
[machine]
55
# Machine-specific optimizations (if using podman machine)
56
cpus = 4
57
disk_size = 100
58
memory = 8192
59

60
[network]
61
# Network performance tuning
62
default_network = "podman"
63
default_subnet = "10.88.0.0/16"
64
default_subnet_pools = [
65
    {"base" = "10.89.0.0/16", "size" = 24},
66
    {"base" = "10.90.0.0/16", "size" = 24}
67
]
68
dns_bind_port = 53
69

70
[secrets]
71
driver = "file"
72
opts = {"path" = "/var/lib/containers/storage/secrets"}
73

74
[service_destinations]
75
# Service mesh optimization
76
EOF
77

78
    echo "containers.conf optimized for performance"
79
}
80

81
# Function to optimize registries.conf
82
optimize_registries_conf() {
83
    local conf_file="/etc/containers/registries.conf"
84

85
    # Backup original configuration
86
    cp "$conf_file" "${conf_file}.backup" 2>/dev/null || true
87

88
    cat > "$conf_file" << EOF
89
# Registry configuration optimized for performance
90

91
[registries.search]
92
registries = [
93
    "registry.fedoraproject.org",
94
    "registry.access.redhat.com",
95
    "docker.io",
96
    "quay.io"
97
]
98

99
[registries.insecure]
100
registries = []
101

102
[registries.block]
103
registries = []
104

105
# Performance optimizations
106
[[registry]]
107
prefix = "docker.io"
108
location = "docker.io"
109

110
[[registry.mirror]]
111
location = "mirror.gcr.io"
112
insecure = false
113

114
[[registry]]
115
prefix = "registry.fedoraproject.org"
116
location = "registry.fedoraproject.org"
117

118
[[registry]]
119
prefix = "quay.io"
120
location = "quay.io"
121

122
# Local registry cache (if available)
123
[[registry]]
124
prefix = "localhost:5000"
125
location = "localhost:5000"
126
insecure = true
127
EOF
128

129
    echo "registries.conf optimized for performance"
130
}
131

132
# Function to create performance monitoring script
133
create_performance_monitor() {
134
    cat > /usr/local/bin/podman-performance-monitor.sh << 'EOF'
135
#!/bin/bash
136
# Real-time Podman performance monitoring
137

138
INTERVAL=5
139
LOG_FILE="/var/log/podman-performance.log"
140

141
# Function to collect metrics
142
collect_metrics() {
143
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
144

145
    # Container counts
146
    local running_containers=$(podman ps -q | wc -l)
147
    local total_containers=$(podman ps -a -q | wc -l)
148

149
    # System resources
150
    local cpu_usage=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | sed 's/%us,//')
151
    local memory_usage=$(free | grep Mem | awk '{printf "%.1f", $3/$2 * 100.0}')
152

153
    # Storage usage
154
    local storage_usage=$(podman system df --format "table {{.Type}}\t{{.Total}}\t{{.Size}}")
155

156
    # Network statistics
157
    local network_stats=$(podman network ls --format "table {{.Name}}\t{{.Driver}}")
158

159
    # Log metrics
160
    echo "[$timestamp] Containers: $running_containers/$total_containers, CPU: ${cpu_usage}%, Memory: ${memory_usage}%" >> "$LOG_FILE"
161

162
    # Alert on high resource usage
163
    if (( $(echo "$cpu_usage > 80" | bc -l) )); then
164
        logger -t podman-monitor "HIGH CPU USAGE: ${cpu_usage}%"
165
    fi
166

167
    if (( $(echo "$memory_usage > 90" | bc -l) )); then
168
        logger -t podman-monitor "HIGH MEMORY USAGE: ${memory_usage}%"
169
    fi
170
}
171

172
# Main monitoring loop
173
while true; do
174
    collect_metrics
175
    sleep $INTERVAL
176
done
177
EOF
178

179
    chmod +x /usr/local/bin/podman-performance-monitor.sh
180

181
    # Create systemd service for monitoring
182
    cat > /etc/systemd/system/podman-performance-monitor.service << EOF
183
[Unit]
184
Description=Podman Performance Monitor
185
After=multi-user.target
186

187
[Service]
188
Type=simple
189
ExecStart=/usr/local/bin/podman-performance-monitor.sh
190
Restart=always
191
RestartSec=10
192
User=root
193

194
[Install]
195
WantedBy=multi-user.target
196
EOF
197

198
    systemctl enable podman-performance-monitor.service
199
    echo "Performance monitoring service created"
200
}
201

202
# Run optimizations
203
optimize_containers_conf
204
optimize_registries_conf
205
create_performance_monitor
206

207
echo "Podman runtime optimization completed!"

1
# high-performance-pod.yaml - Optimized pod configuration
2
apiVersion: v1
3
kind: Pod
4
metadata:
5
  name: high-performance-app
6
  annotations:
7
    io.podman.annotations/init: "false"
8
    io.podman.annotations/privileged: "false"
9
    io.podman.annotations/publish: "8080:8080"
10
spec:
11
  restartPolicy: Always
12
  containers:
13
    - name: app-container
14
      image: nginx:alpine
15
      resources:
16
        requests:
17
          memory: "256Mi"
18
          cpu: "250m"
19
        limits:
20
          memory: "512Mi"
21
          cpu: "500m"
22
      securityContext:
23
        allowPrivilegeEscalation: false
24
        runAsNonRoot: true
25
        runAsUser: 1000
26
        readOnlyRootFilesystem: true
27
        capabilities:
28
          drop:
29
            - ALL
30
          add:
31
            - NET_BIND_SERVICE
32
      volumeMounts:
33
        - name: tmp-volume
34
          mountPath: /tmp
35
        - name: cache-volume
36
          mountPath: /var/cache/nginx
37
        - name: run-volume
38
          mountPath: /var/run
39
  volumes:
40
    - name: tmp-volume
41
      emptyDir:
42
        medium: Memory
43
        sizeLimit: 64Mi
44
    - name: cache-volume
45
      emptyDir:
46
        sizeLimit: 128Mi
47
    - name: run-volume
48
      emptyDir:
49
        medium: Memory
50
        sizeLimit: 32Mi

1
#!/bin/bash
2
# performance-ci-pipeline.sh - Automated performance testing for containers
3

4
set -euo pipefail
5

6
# Configuration
7
BASELINE_THRESHOLD=5.0  # seconds
8
MEMORY_THRESHOLD=512    # MB
9
CI_MODE=${CI_MODE:-false}
10
RESULTS_DIR="performance-results-$(date +%Y%m%d-%H%M%S)"
11

12
# Function to run performance regression tests
13
run_regression_tests() {
14
    echo "Running performance regression tests..."
15

16
    mkdir -p "$RESULTS_DIR"
17

18
    # Test 1: Container startup time
19
    local startup_times=()
20
    for ((i=1; i<=10; i++)); do
21
        local start_time=$(date +%s.%N)
22
        podman run --rm nginx:alpine echo "test" >/dev/null 2>&1
23
        local end_time=$(date +%s.%N)
24
        local duration=$(echo "$end_time - $start_time" | bc)
25
        startup_times+=("$duration")
26
    done
27

28
    # Calculate average startup time
29
    local sum=0
30
    for time in "${startup_times[@]}"; do
31
        sum=$(echo "$sum + $time" | bc)
32
    done
33
    local avg_startup=$(echo "scale=3; $sum / 10" | bc)
34

35
    echo "Average startup time: ${avg_startup}s" | tee "$RESULTS_DIR/startup-time.log"
36

37
    # Check against baseline
38
    if (( $(echo "$avg_startup > $BASELINE_THRESHOLD" | bc -l) )); then
39
        echo "ERROR: Startup time regression detected!" >&2
40
        echo "Expected: < ${BASELINE_THRESHOLD}s, Got: ${avg_startup}s" >&2
41
        if [[ "$CI_MODE" == "true" ]]; then
42
            exit 1
43
        fi
44
    fi
45

46
    # Test 2: Memory usage
47
    local container_id=$(podman run -d nginx:alpine sleep 60)
48
    sleep 5
49

50
    local memory_usage=$(podman stats --no-stream --format "table {{.MemUsage}}" "$container_id" | tail -1 | awk '{print $1}' | sed 's/MiB//')
51

52
    echo "Memory usage: ${memory_usage}MB" | tee "$RESULTS_DIR/memory-usage.log"
53

54
    # Check against threshold
55
    if (( $(echo "$memory_usage > $MEMORY_THRESHOLD" | bc -l) )); then
56
        echo "WARNING: High memory usage detected!" >&2
57
        echo "Threshold: ${MEMORY_THRESHOLD}MB, Got: ${memory_usage}MB" >&2
58
    fi
59

60
    # Cleanup
61
    podman stop "$container_id" >/dev/null 2>&1 || true
62

63
    echo "Regression tests completed successfully"
64
}
65

66
# Function to generate performance report
67
generate_performance_report() {
68
    echo "Generating performance report..."
69

70
    cat > "$RESULTS_DIR/performance-report.md" << EOF
71
# Podman Performance Test Report
72

73
**Date**: $(date)
74
**System**: $(hostname)
75
**Podman Version**: $(podman version --format '{{.Client.Version}}')
76

77
## Test Results
78

79
### Container Startup Performance
80
- Average startup time: $(cat "$RESULTS_DIR/startup-time.log" | grep "Average" | awk '{print $4}')
81
- Baseline threshold: ${BASELINE_THRESHOLD}s
82
- Status: $(if (( $(echo "$(cat "$RESULTS_DIR/startup-time.log" | grep "Average" | awk '{print $4}' | sed 's/s//') <= $BASELINE_THRESHOLD" | bc -l) )); then echo "PASS"; else echo "FAIL"; fi)
83

84
### Memory Usage
85
- Container memory usage: $(cat "$RESULTS_DIR/memory-usage.log" | grep "Memory" | awk '{print $3}')
86
- Memory threshold: ${MEMORY_THRESHOLD}MB
87
- Status: $(if (( $(echo "$(cat "$RESULTS_DIR/memory-usage.log" | grep "Memory" | awk '{print $3}' | sed 's/MB//') <= $MEMORY_THRESHOLD" | bc -l) )); then echo "PASS"; else echo "WARNING"; fi)
88

89
## System Information
90

91
\`\`\`
92
$(podman info)
93
\`\`\`
94

95
## Recommendations
96

97
$(if (( $(echo "$(cat "$RESULTS_DIR/startup-time.log" | grep "Average" | awk '{print $4}' | sed 's/s//') > $BASELINE_THRESHOLD" | bc -l) )); then
98
    echo "- Consider optimizing container startup time"
99
    echo "- Review image layers and optimize Dockerfile"
100
    echo "- Check storage driver performance"
101
fi)
102

103
$(if (( $(echo "$(cat "$RESULTS_DIR/memory-usage.log" | grep "Memory" | awk '{print $3}' | sed 's/MB//') > $MEMORY_THRESHOLD" | bc -l) )); then
104
    echo "- Review memory usage patterns"
105
    echo "- Consider reducing container resource allocation"
106
    echo "- Optimize application memory usage"
107
fi)
108
EOF
109

110
    echo "Performance report generated: $RESULTS_DIR/performance-report.md"
111
}
112

113
# Main execution
114
echo "Starting Podman performance testing pipeline..."
115

116
# Pre-pull test images
117
podman pull nginx:alpine >/dev/null 2>&1
118

119
# Run tests
120
run_regression_tests
121
generate_performance_report
122

123
echo "Performance testing pipeline completed!"
124
echo "Results available in: $RESULTS_DIR"

1
#!/bin/bash
2
# monitoring-setup.sh - Comprehensive monitoring for Podman
3

4
# Install and configure Prometheus node exporter
5
setup_prometheus_monitoring() {
6
    # Create podman metrics exporter
7
    cat > /usr/local/bin/podman-metrics-exporter.py << 'EOF'
8
#!/usr/bin/env python3
9
import json
10
import subprocess
11
import time
12
from http.server import HTTPServer, BaseHTTPRequestHandler
13

14
class MetricsHandler(BaseHTTPRequestHandler):
15
    def do_GET(self):
16
        if self.path == '/metrics':
17
            metrics = self.collect_podman_metrics()
18
            self.send_response(200)
19
            self.send_header('Content-type', 'text/plain')
20
            self.end_headers()
21
            self.wfile.write(metrics.encode())
22
        else:
23
            self.send_response(404)
24
            self.end_headers()
25

26
    def collect_podman_metrics(self):
27
        metrics = []
28

29
        # Container count metrics
30
        try:
31
            running = subprocess.check_output(['podman', 'ps', '-q']).decode().strip().split('\n')
32
            running_count = len([x for x in running if x])
33
            metrics.append(f'podman_containers_running {running_count}')
34

35
            all_containers = subprocess.check_output(['podman', 'ps', '-a', '-q']).decode().strip().split('\n')
36
            total_count = len([x for x in all_containers if x])
37
            metrics.append(f'podman_containers_total {total_count}')
38
        except:
39
            metrics.append('podman_containers_running 0')
40
            metrics.append('podman_containers_total 0')
41

42
        # Image count metrics
43
        try:
44
            images = subprocess.check_output(['podman', 'images', '-q']).decode().strip().split('\n')
45
            image_count = len([x for x in images if x])
46
            metrics.append(f'podman_images_total {image_count}')
47
        except:
48
            metrics.append('podman_images_total 0')
49

50
        # Storage metrics
51
        try:
52
            df_output = subprocess.check_output(['podman', 'system', 'df', '--format', 'json']).decode()
53
            storage_data = json.loads(df_output)
54

55
            for item in storage_data:
56
                item_type = item.get('Type', '').lower()
57
                size = item.get('Size', 0)
58
                reclaimable = item.get('Reclaimable', 0)
59

60
                metrics.append(f'podman_storage_size_bytes{{type="{item_type}"}} {size}')
61
                metrics.append(f'podman_storage_reclaimable_bytes{{type="{item_type}"}} {reclaimable}')
62
        except:
63
            pass
64

65
        return '\n'.join(metrics) + '\n'
66

67
if __name__ == '__main__':
68
    server = HTTPServer(('localhost', 9101), MetricsHandler)
69
    print("Podman metrics exporter started on port 9101")
70
    server.serve_forever()
71
EOF
72

73
    chmod +x /usr/local/bin/podman-metrics-exporter.py
74

75
    # Create systemd service
76
    cat > /etc/systemd/system/podman-metrics-exporter.service << EOF
77
[Unit]
78
Description=Podman Metrics Exporter
79
After=multi-user.target
80

81
[Service]
82
Type=simple
83
ExecStart=/usr/local/bin/podman-metrics-exporter.py
84
Restart=always
85
RestartSec=10
86
User=root
87

88
[Install]
89
WantedBy=multi-user.target
90
EOF
91

92
    systemctl enable podman-metrics-exporter.service
93
    systemctl start podman-metrics-exporter.service
94

95
    echo "Podman metrics exporter configured on port 9101"
96
}
97

98
# Setup log aggregation
99
setup_log_aggregation() {
100
    # Configure journald for container logs
101
    cat > /etc/systemd/journald.conf.d/containers.conf << EOF
102
[Journal]
103
SystemMaxUse=2G
104
SystemKeepFree=1G
105
SystemMaxFileSize=128M
106
RuntimeMaxUse=512M
107
RuntimeKeepFree=256M
108
MaxRetentionSec=7day
109
EOF
110

111
    systemctl restart systemd-journald
112

113
    echo "Log aggregation configured"
114
}
115

116
setup_prometheus_monitoring
117
setup_log_aggregation
118

119
echo "Monitoring setup completed!"