Podman 無 Root 容器網路深度剖析:從網路隔離到服務暴露的完整實踐

#!/bin/bash

# 無 Root 容器網路檢查腳本
# 用於驗證 slirp4netns 的網路隔離機制

# 設置顏色輸出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

echo -e "${GREEN}=== Podman 無 Root 容器網路檢查 ===${NC}\n"

# 檢查 Podman 版本
echo -e "${YELLOW}檢查 Podman 版本:${NC}"
podman version --format "Version: {{.Version}}"
echo ""

# 啟動測試容器
echo -e "${YELLOW}啟動測試容器...${NC}"
CONTAINER_ID=$(podman run -d --name network-test busybox sleep 3600)

if [ $? -eq 0 ]; then
    echo -e "${GREEN}容器啟動成功 (ID: ${CONTAINER_ID:0:12})${NC}\n"
else
    echo -e "${RED}容器啟動失敗${NC}"
    exit 1
fi

# 檢查容器內的網路介面
echo -e "${YELLOW}檢查容器內的 tap0 介面:${NC}"
podman exec network-test ip addr show tap0

if [ $? -eq 0 ]; then
    echo -e "\n${GREEN}✓ tap0 介面配置正常${NC}\n"
else
    echo -e "\n${RED}✗ 無法找到 tap0 介面${NC}\n"
fi

# 檢查容器的路由表
echo -e "${YELLOW}檢查容器的路由表:${NC}"
podman exec network-test ip route show
echo ""

# 檢查無 Root 網路名稱空間
echo -e "${YELLOW}檢查無 Root 網路名稱空間中的 tap0:${NC}"
podman unshare --rootless-netns ip addr show tap0

if [ $? -eq 0 ]; then
    echo -e "\n${GREEN}✓ 網路名稱空間配置正常${NC}\n"
else
    echo -e "\n${RED}✗ 無法訪問網路名稱空間${NC}\n"
fi

# 檢查 slirp4netns 進程
echo -e "${YELLOW}檢查 slirp4netns 進程:${NC}"
ps aux | grep slirp4netns | grep -v grep
echo ""

# 測試容器的網路連通性
echo -e "${YELLOW}測試容器的網路連通性:${NC}"
podman exec network-test ping -c 3 8.8.8.8

if [ $? -eq 0 ]; then
    echo -e "\n${GREEN}✓ 網路連通性正常${NC}\n"
else
    echo -e "\n${RED}✗ 網路連通性異常${NC}\n"
fi

# 檢查容器的 DNS 配置
echo -e "${YELLOW}檢查容器的 DNS 配置:${NC}"
podman exec network-test cat /etc/resolv.conf
echo ""

# 清理測試容器
echo -e "${YELLOW}清理測試容器...${NC}"
podman stop network-test > /dev/null 2>&1
podman rm network-test > /dev/null 2>&1
echo -e "${GREEN}清理完成${NC}\n"

echo -e "${GREEN}=== 網路檢查完成 ===${NC}"

#!/bin/bash

# Podman 自定義網路容器互連範例
# 展示如何創建自定義網路並實現容器間通訊

set -e  # 遇到錯誤立即退出

# 設置顏色輸出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

echo -e "${GREEN}=== Podman 自定義網路容器互連範例 ===${NC}\n"

# 清理現有資源
echo -e "${YELLOW}清理現有資源...${NC}"
podman stop frontend backend 2>/dev/null || true
podman rm frontend backend 2>/dev/null || true
podman network rm app-network 2>/dev/null || true
echo -e "${GREEN}清理完成${NC}\n"

# 創建自定義網路
echo -e "${YELLOW}創建自定義網路 'app-network'...${NC}"
podman network create app-network

if [ $? -eq 0 ]; then
    echo -e "${GREEN}✓ 網路創建成功${NC}\n"
else
    echo -e "${RED}✗ 網路創建失敗${NC}"
    exit 1
fi

# 檢查網路詳細資訊
echo -e "${YELLOW}檢查網路配置:${NC}"
podman network inspect app-network
echo ""

# 啟動後端容器
echo -e "${YELLOW}啟動後端容器...${NC}"
podman run -d \
    --name backend \
    --network app-network \
    --cap-add=net_admin,net_raw \
    busybox \
    sh -c 'while true; do echo "Backend responding: $(date)" | nc -l -p 8080; done'

if [ $? -eq 0 ]; then
    echo -e "${GREEN}✓ 後端容器啟動成功${NC}"
else
    echo -e "${RED}✗ 後端容器啟動失敗${NC}"
    exit 1
fi

# 等待容器完全啟動
sleep 2

# 獲取後端容器的 IP 位址
BACKEND_IP=$(podman inspect backend --format '{{.NetworkSettings.Networks.app-network.IPAddress}}')
echo -e "${BLUE}後端容器 IP: ${BACKEND_IP}${NC}\n"

# 啟動前端容器
echo -e "${YELLOW}啟動前端容器...${NC}"
podman run -d \
    --name frontend \
    --network app-network \
    --cap-add=net_admin,net_raw \
    busybox \
    sleep 3600

if [ $? -eq 0 ]; then
    echo -e "${GREEN}✓ 前端容器啟動成功${NC}\n"
else
    echo -e "${RED}✗ 前端容器啟動失敗${NC}"
    exit 1
fi

# 測試容器間通訊 - 透過容器名稱
echo -e "${YELLOW}測試容器間通訊 (透過容器名稱):${NC}"
echo -e "${BLUE}從 frontend 容器 ping backend 容器...${NC}"
podman exec frontend ping -c 3 backend

if [ $? -eq 0 ]; then
    echo -e "\n${GREEN}✓ DNS 解析與網路通訊正常${NC}\n"
else
    echo -e "\n${RED}✗ 網路通訊失敗${NC}\n"
fi

# 測試容器間通訊 - 透過 IP 位址
echo -e "${YELLOW}測試容器間通訊 (透過 IP 位址):${NC}"
echo -e "${BLUE}從 frontend 容器 ping ${BACKEND_IP}...${NC}"
podman exec frontend ping -c 3 $BACKEND_IP
echo ""

# 檢查網路名稱空間中的虛擬設備
echo -e "${YELLOW}檢查網路名稱空間中的虛擬設備:${NC}"
podman unshare --rootless-netns ip link | grep -E 'podman|veth'
echo ""

# 檢查 DNS 配置
echo -e "${YELLOW}檢查容器的 DNS 配置:${NC}"
echo -e "${BLUE}Frontend 容器的 /etc/resolv.conf:${NC}"
podman exec frontend cat /etc/resolv.conf
echo ""

# 檢查 aardvark-dns 配置 (Netavark 後端)
echo -e "${YELLOW}檢查 aardvark-dns 配置:${NC}"
DNS_CONFIG="/run/user/$(id -u)/containers/networks/aardvark-dns/app-network"
if [ -f "$DNS_CONFIG" ]; then
    echo -e "${BLUE}DNS 記錄:${NC}"
    cat $DNS_CONFIG
    echo ""
else
    echo -e "${YELLOW}注意: 使用的是 CNI 網路後端${NC}\n"
fi

# 顯示網路拓撲
echo -e "${GREEN}=== 網路拓撲 ===${NC}"
echo -e "自定義網路: app-network"
echo -e "  ├─ backend  (IP: ${BACKEND_IP})"
echo -e "  └─ frontend (服務埠: 8080)"
echo ""

# 測試應用層通訊
echo -e "${YELLOW}測試應用層通訊:${NC}"
echo -e "${BLUE}嘗試連接後端服務...${NC}"
timeout 5 podman exec frontend sh -c "echo 'Test request' | nc backend 8080" || true
echo ""

echo -e "${GREEN}=== 容器互連測試完成 ===${NC}"
echo -e "${YELLOW}提示: 容器將繼續運行,使用以下命令清理:${NC}"
echo -e "  podman stop frontend backend"
echo -e "  podman rm frontend backend"
echo -e "  podman network rm app-network"

#!/usr/bin/env python3
"""
Podman 容器 DNS 配置檢查工具
支援 CNI 與 Netavark 兩種網路後端
"""

import subprocess
import json
import os
import sys
from pathlib import Path
from typing import Dict, List, Optional

class Color:
    """終端顏色常數"""
    RED = '\033[0;31m'
    GREEN = '\033[0;32m'
    YELLOW = '\033[1;33m'
    BLUE = '\033[0;34m'
    CYAN = '\033[0;36m'
    NC = '\033[0m'  # No Color

class PodmanDNSChecker:
    """Podman DNS 配置檢查器"""
    
    def __init__(self):
        """初始化檢查器"""
        self.user_id = os.getuid()
        self.network_backend = self._detect_network_backend()
    
    def _detect_network_backend(self) -> str:
        """
        檢測使用的網路後端
        
        回傳:
            'cni' 或 'netavark'
        """
        try:
            # 執行 podman info 命令獲取系統資訊
            result = subprocess.run(
                ['podman', 'info', '--format', 'json'],
                capture_output=True,
                text=True,
                check=True
            )
            
            info = json.loads(result.stdout)
            # 檢查 networkBackend 欄位
            backend = info.get('host', {}).get('networkBackend', 'unknown')
            return backend.lower()
            
        except subprocess.CalledProcessError as e:
            print(f"{Color.RED}錯誤: 無法執行 podman info{Color.NC}")
            print(f"錯誤訊息: {e.stderr}")
            sys.exit(1)
        except json.JSONDecodeError:
            print(f"{Color.RED}錯誤: 無法解析 podman info 輸出{Color.NC}")
            sys.exit(1)
    
    def list_networks(self) -> List[Dict]:
        """
        列出所有容器網路
        
        回傳:
            網路資訊列表
        """
        try:
            result = subprocess.run(
                ['podman', 'network', 'ls', '--format', 'json'],
                capture_output=True,
                text=True,
                check=True
            )
            
            return json.loads(result.stdout)
            
        except subprocess.CalledProcessError as e:
            print(f"{Color.RED}錯誤: 無法列出網路{Color.NC}")
            print(f"錯誤訊息: {e.stderr}")
            return []
    
    def inspect_network(self, network_name: str) -> Optional[Dict]:
        """
        檢查特定網路的詳細資訊
        
        參數:
            network_name: 網路名稱
            
        回傳:
            網路詳細資訊
        """
        try:
            result = subprocess.run(
                ['podman', 'network', 'inspect', network_name],
                capture_output=True,
                text=True,
                check=True
            )
            
            network_info = json.loads(result.stdout)
            return network_info[0] if network_info else None
            
        except subprocess.CalledProcessError:
            return None
    
    def check_dns_config_netavark(self, network_name: str) -> None:
        """
        檢查 Netavark 後端的 DNS 配置
        
        參數:
            network_name: 網路名稱
        """
        print(f"\n{Color.CYAN}=== Netavark DNS 配置 ==={Color.NC}\n")
        
        # aardvark-dns 配置檔路徑
        config_dir = Path(f"/run/user/{self.user_id}/containers/networks/aardvark-dns")
        config_file = config_dir / network_name
        
        if config_file.exists():
            print(f"{Color.GREEN}✓ 找到 DNS 配置檔{Color.NC}")
            print(f"{Color.YELLOW}配置檔路徑: {config_file}{Color.NC}\n")
            
            # 讀取並顯示配置內容
            with open(config_file, 'r') as f:
                content = f.read()
                print(f"{Color.BLUE}DNS 記錄:{Color.NC}")
                print(content)
                
                # 解析 DNS 記錄
                lines = content.strip().split('\n')
                if lines:
                    gateway = lines[0]
                    print(f"\n{Color.YELLOW}網關地址: {gateway}{Color.NC}")
                    
                    if len(lines) > 1:
                        print(f"{Color.YELLOW}容器記錄:{Color.NC}")
                        for line in lines[1:]:
                            parts = line.split()
                            if len(parts) >= 3:
                                container_id = parts[0]
                                ip_address = parts[1]
                                names = parts[2]
                                print(f"  {Color.CYAN}{names}{Color.NC} -> {ip_address}")
        else:
            print(f"{Color.RED}✗ 未找到 DNS 配置檔{Color.NC}")
            print(f"預期路徑: {config_file}")
    
    def check_dns_config_cni(self, network_name: str) -> None:
        """
        檢查 CNI 後端的 DNS 配置
        
        參數:
            network_name: 網路名稱
        """
        print(f"\n{Color.CYAN}=== CNI DNS 配置 ==={Color.NC}\n")
        
        # dnsmasq 配置檔路徑
        config_dir = Path(f"/run/containers/cni/dnsname/{network_name}")
        dnsmasq_conf = config_dir / "dnsmasq.conf"
        addnhosts = config_dir / "addnhosts"
        
        if dnsmasq_conf.exists():
            print(f"{Color.GREEN}✓ 找到 dnsmasq 配置{Color.NC}")
            print(f"{Color.YELLOW}配置檔路徑: {dnsmasq_conf}{Color.NC}\n")
            
            # 讀取並顯示 dnsmasq 配置
            with open(dnsmasq_conf, 'r') as f:
                print(f"{Color.BLUE}dnsmasq 配置:{Color.NC}")
                print(f.read())
        else:
            print(f"{Color.RED}✗ 未找到 dnsmasq 配置{Color.NC}")
        
        if addnhosts.exists():
            print(f"\n{Color.GREEN}✓ 找到主機記錄檔{Color.NC}")
            print(f"{Color.YELLOW}主機記錄路徑: {addnhosts}{Color.NC}\n")
            
            # 讀取並顯示主機記錄
            with open(addnhosts, 'r') as f:
                print(f"{Color.BLUE}主機記錄:{Color.NC}")
                for line in f:
                    line = line.strip()
                    if line and not line.startswith('#'):
                        parts = line.split()
                        if len(parts) >= 2:
                            ip = parts[0]
                            name = parts[1]
                            print(f"  {Color.CYAN}{name}{Color.NC} -> {ip}")
        else:
            print(f"{Color.RED}✗ 未找到主機記錄檔{Color.NC}")
    
    def check_container_dns(self, container_name: str) -> None:
        """
        檢查容器內的 DNS 配置
        
        參數:
            container_name: 容器名稱
        """
        print(f"\n{Color.CYAN}=== 容器 DNS 配置 ==={Color.NC}\n")
        
        try:
            # 檢查 /etc/resolv.conf
            result = subprocess.run(
                ['podman', 'exec', container_name, 'cat', '/etc/resolv.conf'],
                capture_output=True,
                text=True,
                check=True
            )
            
            print(f"{Color.GREEN}✓ 容器 {container_name} 的 DNS 配置{Color.NC}")
            print(f"{Color.BLUE}/etc/resolv.conf:{Color.NC}")
            print(result.stdout)
            
            # 解析 nameserver
            for line in result.stdout.split('\n'):
                if line.startswith('nameserver'):
                    nameserver = line.split()[1]
                    print(f"{Color.YELLOW}DNS 伺服器: {nameserver}{Color.NC}")
                elif line.startswith('search'):
                    search_domain = line.split()[1]
                    print(f"{Color.YELLOW}搜尋域: {search_domain}{Color.NC}")
            
        except subprocess.CalledProcessError:
            print(f"{Color.RED}✗ 無法讀取容器 DNS 配置{Color.NC}")
    
    def run_checks(self, network_name: str = None, container_name: str = None):
        """
        執行完整的 DNS 配置檢查
        
        參數:
            network_name: 要檢查的網路名稱(可選)
            container_name: 要檢查的容器名稱(可選)
        """
        print(f"{Color.GREEN}=== Podman DNS 配置檢查工具 ==={Color.NC}\n")
        
        # 顯示網路後端
        print(f"{Color.YELLOW}檢測到的網路後端: {self.network_backend.upper()}{Color.NC}")
        
        # 列出所有網路
        networks = self.list_networks()
        print(f"\n{Color.YELLOW}可用網路數量: {len(networks)}{Color.NC}")
        
        # 如果指定了網路名稱,檢查該網路
        if network_name:
            network_info = self.inspect_network(network_name)
            if network_info:
                print(f"\n{Color.CYAN}檢查網路: {network_name}{Color.NC}")
                
                # 根據後端類型檢查 DNS 配置
                if self.network_backend == 'netavark':
                    self.check_dns_config_netavark(network_name)
                elif self.network_backend == 'cni':
                    self.check_dns_config_cni(network_name)
            else:
                print(f"{Color.RED}錯誤: 找不到網路 {network_name}{Color.NC}")
        
        # 如果指定了容器名稱,檢查容器 DNS 配置
        if container_name:
            self.check_container_dns(container_name)

def main():
    """主函式"""
    import argparse
    
    parser = argparse.ArgumentParser(
        description='Podman 容器 DNS 配置檢查工具'
    )
    parser.add_argument(
        '-n', '--network',
        help='要檢查的網路名稱'
    )
    parser.add_argument(
        '-c', '--container',
        help='要檢查的容器名稱'
    )
    
    args = parser.parse_args()
    
    # 創建檢查器實例
    checker = PodmanDNSChecker()
    
    # 執行檢查
    checker.run_checks(
        network_name=args.network,
        container_name=args.container
    )

if __name__ == '__main__':
    main()

#!/bin/bash

# Podman Pod 網路共享範例
# 展示如何創建 Pod 並實現容器間的網路共享

set -e  # 遇到錯誤立即退出

# 設置顏色輸出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color

echo -e "${GREEN}=== Podman Pod 網路共享範例 ===${NC}\n"

# 清理現有資源
echo -e "${YELLOW}清理現有資源...${NC}"
podman pod stop microservice-pod 2>/dev/null || true
podman pod rm microservice-pod 2>/dev/null || true
echo -e "${GREEN}清理完成${NC}\n"

# 創建 Pod
echo -e "${YELLOW}創建 Pod 'microservice-pod'...${NC}"
podman pod create \
    --name microservice-pod \
    --publish 8080:8080 \
    --publish 8081:8081

if [ $? -eq 0 ]; then
    echo -e "${GREEN}✓ Pod 創建成功${NC}\n"
else
    echo -e "${RED}✗ Pod 創建失敗${NC}"
    exit 1
fi

# 檢查 Pod 狀態
echo -e "${YELLOW}檢查 Pod 狀態:${NC}"
podman pod ps
echo ""

# 檢查基礎容器
echo -e "${YELLOW}檢查基礎容器 (infra container):${NC}"
podman ps --filter pod=microservice-pod --format "table {{.ID}}\t{{.Image}}\t{{.Names}}"
echo ""

# 添加 Web 服務容器
echo -e "${YELLOW}添加 Web 服務容器...${NC}"
podman run -d \
    --pod microservice-pod \
    --name web-service \
    --label "service=web" \
    docker.io/library/nginx:alpine

if [ $? -eq 0 ]; then
    echo -e "${GREEN}✓ Web 服務容器啟動成功${NC}\n"
else
    echo -e "${RED}✗ Web 服務容器啟動失敗${NC}"
    exit 1
fi

# 添加 API 服務容器
echo -e "${YELLOW}添加 API 服務容器...${NC}"
podman run -d \
    --pod microservice-pod \
    --name api-service \
    --label "service=api" \
    busybox \
    sh -c 'while true; do echo -e "HTTP/1.1 200 OK\n\n{\"status\":\"ok\",\"service\":\"api\"}" | nc -l -p 8081; done'

if [ $? -eq 0 ]; then
    echo -e "${GREEN}✓ API 服務容器啟動成功${NC}\n"
else
    echo -e "${RED}✗ API 服務容器啟動失敗${NC}"
    exit 1
fi

# 等待服務啟動
echo -e "${YELLOW}等待服務完全啟動...${NC}"
sleep 3
echo -e "${GREEN}服務啟動完成${NC}\n"

# 檢查 Pod 內所有容器
echo -e "${YELLOW}Pod 內所有容器:${NC}"
podman ps --filter pod=microservice-pod --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
echo ""

# 檢查網路配置
echo -e "${YELLOW}檢查 Pod 的網路配置:${NC}"
POD_IP=$(podman inspect microservice-pod --format '{{.InfraContainerID}}' | xargs podman inspect --format '{{.NetworkSettings.IPAddress}}')
echo -e "${BLUE}Pod IP 位址: ${POD_IP}${NC}\n"

# 驗證網路名稱空間共享
echo -e "${YELLOW}驗證網路名稱空間共享:${NC}"
echo -e "${BLUE}檢查 web-service 容器的網路介面:${NC}"
podman exec web-service ip addr show eth0
echo ""

echo -e "${BLUE}檢查 api-service 容器的網路介面:${NC}"
podman exec api-service ip addr show eth0
echo ""

# 測試容器間通訊 (透過 localhost)
echo -e "${YELLOW}測試容器間通訊 (透過 localhost):${NC}"
echo -e "${BLUE}從 web-service 訪問 api-service...${NC}"
podman exec web-service wget -qO- http://localhost:8081
echo -e "\n${GREEN}✓ 容器間通訊成功${NC}\n"

# 測試從主機訪問 Pod 服務
echo -e "${YELLOW}測試從主機訪問 Pod 服務:${NC}"
echo -e "${BLUE}訪問 Web 服務 (埠 8080):${NC}"
curl -s http://localhost:8080 | head -n 5
echo "..."
echo -e "\n${BLUE}訪問 API 服務 (埠 8081):${NC}"
curl -s http://localhost:8081
echo -e "\n${GREEN}✓ 主機訪問 Pod 服務成功${NC}\n"

# 顯示 Pod 架構
echo -e "${CYAN}=== Pod 架構 ===${NC}"
echo -e "microservice-pod"
echo -e "  ├─ infra container (pause)"
echo -e "  │  └─ 網路名稱空間: ${POD_IP}"
echo -e "  ├─ web-service (nginx)"
echo -e "  │  └─ 監聽: localhost:80 → Pod:8080"
echo -e "  └─ api-service (busybox)"
echo -e "     └─ 監聽: localhost:8081 → Pod:8081"
echo ""

# 顯示網路名稱空間資訊
echo -e "${YELLOW}檢查網路名稱空間:${NC}"
INFRA_ID=$(podman inspect microservice-pod --format '{{.InfraContainerID}}')
NETNS=$(podman inspect $INFRA_ID --format '{{.NetworkSettings.SandboxKey}}')
echo -e "${BLUE}網路名稱空間: ${NETNS}${NC}\n"

# 使用 podman unshare 檢查網路配置
echo -e "${YELLOW}使用 podman unshare 檢查網路配置:${NC}"
podman unshare --rootless-netns ip addr show | grep -A 10 "inet "
echo ""

echo -e "${GREEN}=== Pod 網路共享範例完成 ===${NC}"
echo -e "${YELLOW}提示: Pod 將繼續運行,使用以下命令清理:${NC}"
echo -e "  podman pod stop microservice-pod"
echo -e "  podman pod rm microservice-pod"

#!/bin/bash

# Podman 埠暴露與防火牆配置範例
# 展示各種埠映射方式與安全配置

set -e  # 遇到錯誤立即退出

# 設置顏色輸出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color

echo -e "${GREEN}=== Podman 埠暴露與防火牆配置範例 ===${NC}\n"

# 檢查是否為 root 用戶
if [ "$EUID" -eq 0 ]; then
    echo -e "${YELLOW}警告: 以 root 身份運行${NC}"
    IS_ROOT=true
else
    echo -e "${BLUE}以非 root 用戶運行 (無 Root 容器)${NC}"
    IS_ROOT=false
fi
echo ""

# 清理現有資源
echo -e "${YELLOW}清理現有資源...${NC}"
podman stop test-http test-https test-range test-localhost 2>/dev/null || true
podman rm test-http test-https test-range test-localhost 2>/dev/null || true
echo -e "${GREEN}清理完成${NC}\n"

# 範例 1: 基本埠映射
echo -e "${CYAN}=== 範例 1: 基本埠映射 ===${NC}"
echo -e "${YELLOW}將容器的 80 埠映射到主機的 8080 埠${NC}"

podman run -d \
    --name test-http \
    -p 8080:80 \
    docker.io/library/nginx:alpine

if [ $? -eq 0 ]; then
    echo -e "${GREEN}✓ 容器啟動成功${NC}"
    
    # 檢查埠映射
    echo -e "${BLUE}檢查埠映射:${NC}"
    podman port test-http
    
    # 測試訪問
    echo -e "\n${BLUE}測試服務訪問:${NC}"
    sleep 2
    curl -s http://localhost:8080 | head -n 5
    echo "..."
    echo -e "${GREEN}✓ 服務訪問成功${NC}\n"
else
    echo -e "${RED}✗ 容器啟動失敗${NC}\n"
fi

# 範例 2: 指定 IP 綁定
echo -e "${CYAN}=== 範例 2: 指定 IP 綁定 (僅本機訪問) ===${NC}"
echo -e "${YELLOW}將服務綁定到 127.0.0.1,只允許本機訪問${NC}"

podman run -d \
    --name test-localhost \
    -p 127.0.0.1:8081:80 \
    docker.io/library/nginx:alpine

if [ $? -eq 0 ]; then
    echo -e "${GREEN}✓ 容器啟動成功${NC}"
    
    # 顯示網路綁定
    echo -e "${BLUE}網路綁定資訊:${NC}"
    ss -tlnp | grep 8081 || netstat -tlnp | grep 8081 2>/dev/null || echo "端口 8081 已綁定"
    
    echo -e "\n${YELLOW}注意: 此服務只能從本機訪問${NC}"
    echo -e "${BLUE}本機訪問: curl http://localhost:8081${NC}"
    echo -e "${RED}外部訪問將被拒絕${NC}\n"
else
    echo -e "${RED}✗ 容器啟動失敗${NC}\n"
fi

# 範例 3: 埠範圍映射
echo -e "${CYAN}=== 範例 3: 埠範圍映射 ===${NC}"
echo -e "${YELLOW}同時映射多個連續埠 (8100-8102)${NC}"

podman run -d \
    --name test-range \
    -p 8100-8102:80-82 \
    docker.io/library/nginx:alpine

if [ $? -eq 0 ]; then
    echo -e "${GREEN}✓ 容器啟動成功${NC}"
    
    # 檢查所有映射的埠
    echo -e "${BLUE}映射的埠範圍:${NC}"
    podman port test-range
    
    echo -e "\n${YELLOW}可以訪問 8100, 8101, 8102 三個埠${NC}\n"
else
    echo -e "${RED}✗ 容器啟動失敗${NC}\n"
fi

# 檢查防火牆狀態
echo -e "${CYAN}=== 防火牆配置檢查 ===${NC}"
echo -e "${YELLOW}檢查系統防火牆狀態...${NC}"

if command -v firewall-cmd &> /dev/null; then
    echo -e "${BLUE}檢測到 firewalld${NC}"
    
    # 檢查防火牆是否運行
    if systemctl is-active --quiet firewalld; then
        echo -e "${GREEN}✓ firewalld 正在運行${NC}\n"
        
        # 顯示當前開放的埠
        echo -e "${YELLOW}當前開放的埠:${NC}"
        firewall-cmd --list-ports
        
        # 顯示建議的防火牆規則
        echo -e "\n${CYAN}=== 防火牆配置建議 ===${NC}"
        echo -e "${YELLOW}要永久開放埠 8080,執行以下命令:${NC}"
        echo -e "${BLUE}sudo firewall-cmd --add-port=8080/tcp --permanent${NC}"
        echo -e "${BLUE}sudo firewall-cmd --reload${NC}\n"
        
        echo -e "${YELLOW}要開放埠範圍 8000-8100,執行:${NC}"
        echo -e "${BLUE}sudo firewall-cmd --add-port=8000-8100/tcp --permanent${NC}"
        echo -e "${BLUE}sudo firewall-cmd --reload${NC}\n"
    else
        echo -e "${YELLOW}firewalld 未運行${NC}\n"
    fi
elif command -v ufw &> /dev/null; then
    echo -e "${BLUE}檢測到 ufw (Ubuntu 防火牆)${NC}"
    
    # 檢查 ufw 狀態
    UFW_STATUS=$(sudo ufw status | head -n 1)
    echo -e "${YELLOW}UFW 狀態: ${UFW_STATUS}${NC}\n"
    
    if echo "$UFW_STATUS" | grep -q "active"; then
        echo -e "${CYAN}=== UFW 配置建議 ===${NC}"
        echo -e "${YELLOW}要開放埠 8080,執行:${NC}"
        echo -e "${BLUE}sudo ufw allow 8080/tcp${NC}\n"
    fi
else
    echo -e "${YELLOW}未檢測到常見的防火牆工具${NC}\n"
fi

# 安全性最佳實務
echo -e "${CYAN}=== 安全性最佳實務 ===${NC}"
echo -e "${YELLOW}1. 最小化埠暴露${NC}"
echo -e "   只開放必要的埠,避免暴露管理介面"
echo ""
echo -e "${YELLOW}2. 使用特定 IP 綁定${NC}"
echo -e "   內部服務綁定到 127.0.0.1 或內網 IP"
echo ""
echo -e "${YELLOW}3. 實施網路分段${NC}"
echo -e "   使用自定義網路隔離不同類型的容器"
echo ""
echo -e "${YELLOW}4. 配置防火牆規則${NC}"
echo -e "   在主機層面實施額外的訪問控制"
echo ""
echo -e "${YELLOW}5. 使用反向代理${NC}"
echo -e "   透過 nginx/traefik 統一管理外部訪問"
echo ""
echo -e "${YELLOW}6. 啟用 TLS/SSL${NC}"
echo -e "   對外部訪問啟用加密連接"
echo ""

# 無 Root 容器的限制說明
if [ "$IS_ROOT" = false ]; then
    echo -e "${CYAN}=== 無 Root 容器的埠限制 ===${NC}"
    echo -e "${RED}重要: 無 Root 容器無法綁定特權埠 (1-1024)${NC}"
    echo -e "${YELLOW}解決方案:${NC}"
    echo -e "  1. 使用 1024 以上的埠 (如 8080 代替 80)"
    echo -e "  2. 配置主機埠轉發"
    echo -e "  3. 使用反向代理 (nginx/haproxy)"
    echo ""
    
    echo -e "${YELLOW}埠轉發範例 (需要 root 權限):${NC}"
    echo -e "${BLUE}sudo iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 8080${NC}"
    echo ""
fi

# 顯示當前所有容器的埠映射
echo -e "${CYAN}=== 當前所有容器的埠映射 ===${NC}"
podman ps --format "table {{.Names}}\t{{.Ports}}\t{{.Status}}"
echo ""

echo -e "${GREEN}=== 埠暴露範例完成 ===${NC}"
echo -e "${YELLOW}提示: 容器將繼續運行,使用以下命令清理:${NC}"
echo -e "  podman stop test-http test-https test-range test-localhost"
echo -e "  podman rm test-http test-https test-range test-localhost"