---
# System prepended metadata

title: VS Code Remote SSH 設定指南 - VMware

---

# VS Code Remote SSH 設定指南 - VMware Ubuntu VM (支援多人同時連線)

## 概述

本指南將幫您在 VMware Ubuntu Linux VM 上建立一個安全的 VS Code Remote SSH 環境，支援多人同時連線使用，包含 Amazon Q CLI 安裝和受限制的用戶權限設定。

## 前置需求

- VMware 環境
- Ubuntu 22.04 LTS Server 版本 (建議使用 Server 版以節省資源)
- 高規格主機硬體 (詳見 VM 規格需求)
- 本機已安裝 VS Code 和 Remote-SSH 擴展

## 架構示意圖

```mermaid
graph TB
    subgraph "本機環境"
        U1["用戶01<br/>VS Code + Remote SSH"]
        U2["用戶02<br/>VS Code + Remote SSH"]
        U3["用戶03<br/>VS Code + Remote SSH"]
        U4["用戶04<br/>VS Code + Remote SSH"]
        U5["用戶05<br/>VS Code + Remote SSH"]
        UD["... 用戶20<br/>VS Code + Remote SSH"]
    end
    
    subgraph "VMware Ubuntu Server"
        subgraph "系統服務"
            SSHD["SSH Daemon<br/>MaxSessions: 50"]
            FB["Fail2Ban 安全防護"]
            UFW["UFW 防火牆"]
        end
        
        subgraph "用戶環境"
            USER1["/home/user01<br/>受限制環境<br/>VS Code Server<br/>Amazon Q CLI"]
            USER2["/home/user02<br/>受限制環境<br/>VS Code Server<br/>Amazon Q CLI"]
            USER3["/home/user03<br/>受限制環境<br/>VS Code Server<br/>Amazon Q CLI"]
            USERN["/home/user20<br/>受限制環境<br/>VS Code Server<br/>Amazon Q CLI"]
        end
        
        subgraph "系統資源"
            CPU["16-20 核心 CPU"]
            RAM["64-80GB RAM"]
            DISK["500GB SSD"]
        end
        
        subgraph "安全限制"
            ACL["ACL 權限控制"]
            RESTRICT["目錄存取限制<br/>/etc /root /var"]
            ISOLATE["用戶隔離<br/>只能存取自己家目錄"]
        end
    end
    
    subgraph "外部服務"
        QAPI["Amazon Q API<br/>AI 助手服務"]
        ADO["ADO 程式碼倉庫"]
        VSCODE_CDN["VS Code CDN<br/>擴展和更新"]
    end
    
    U1 --> SSHD
    U2 --> SSHD
    U3 --> SSHD
    U4 --> SSHD
    U5 --> SSHD
    UD --> SSHD
    
    SSHD --> USER1
    SSHD --> USER2
    SSHD --> USER3
    SSHD --> USERN
    
    USER1 -.-> QAPI
    USER2 -.-> QAPI
    USER3 -.-> QAPI
    USERN -.-> QAPI
    
    USER1 -.-> ADO
    USER2 -.-> ADO
    USER3 -.-> ADO
    USERN -.-> ADO
    
    SSHD -.-> VSCODE_CDN
```

## 工作流程說明

```mermaid
sequenceDiagram
    participant User as 👤 用戶本機<br/>VS Code
    participant SSH as 🔐 SSH 連接
    participant Server as 🖥️ Ubuntu Server
    participant VSCode as 📁 VS Code Server
    participant Q as ⚡ Amazon Q CLI
    participant API as ☁️ Amazon Q API
    
    Note over User,API: 用戶連接和工作流程
    
    User->>SSH: 1. SSH 金鑰認證
    SSH->>Server: 2. 建立安全連接
    Server->>VSCode: 3. 啟動 VS Code Server<br/>(預安裝，快速啟動)
    VSCode-->>User: 4. 建立 VS Code 通信通道
    
    Note over User,VSCode: VS Code Remote 環境已就緒
    
    User->>VSCode: 5. 開啟終端機
    VSCode->>Q: 6. 執行 q chat 命令
    Q->>API: 7. 發送查詢到 Amazon Q
    API-->>Q: 8. 返回 AI 回應
    Q-->>VSCode: 9. 顯示回應結果
    VSCode-->>User: 10. 用戶看到 AI 回應
    
    Note over User,API: 持續的開發和 AI 協助循環
```

## 步驟 1: 建立 Ubuntu VM

### 1.1 VM 規格需求 (20 人同時使用)

#### 推薦規格
```bash
# 生產環境規格 (20 人同時使用)
- CPU: 16-20 核心 (每人約 1 核心)
- RAM: 64-80GB (每人約 3-4GB)
- 磁碟: 500GB SSD (每人約 25GB)
- 網路: 橋接模式 (更好的網路效能)
- 交換空間: 16GB
```

#### 最低規格
```bash
# 最低可接受規格 (可能影響效能)
- CPU: 12 核心
- RAM: 48GB
- 磁碟: 300GB
- 網路: NAT 模式
- 交換空間: 8GB
```

#### 資源計算說明
```bash
# 每個用戶預估資源使用量
- VS Code Server: 200-400MB RAM
- Node.js 進程: 100-200MB RAM
- Amazon Q CLI: 50-100MB RAM
- Shell 和系統進程: 50-100MB RAM
- 磁碟空間: 20-25GB (包含 VS Code extensions)
- CPU: 輕度使用 0.5-1 核心，重度使用 1-2 核心
```

### 1.2 安裝 Ubuntu Server
1. 下載 Ubuntu 22.04 LTS Server ISO
2. 在 VMware 中建立新 VM，分配上述規格
3. 完成 Ubuntu Server 安裝，建立管理員用戶
4. 選擇安裝 OpenSSH Server

### 1.3 系統效能調優
```bash
# 設定交換空間 (如果安裝時未設定)
sudo fallocate -l 16G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

# 調整系統參數以支援更多並發連線
sudo tee -a /etc/sysctl.conf << 'EOF'
# 支援更多並發連線
net.core.somaxconn = 1024
net.ipv4.tcp_max_syn_backlog = 2048
fs.file-max = 65536

# 記憶體管理優化
vm.swappiness = 10
vm.dirty_ratio = 15
vm.dirty_background_ratio = 5
EOF

sudo sysctl -p
```

### 1.4 取得 VM IP 位址
```bash
# 在 VM 中執行
ip addr show
# 記錄 IP 位址，例如：192.168.1.100
```

## 步驟 2: 系統基礎設定

### 2.1 更新系統
```bash
sudo apt update && sudo apt upgrade -y
```

### 2.2 安裝必要套件
```bash
sudo apt install -y openssh-server curl wget git nodejs npm acl htop iotop \
    build-essential python3-pip unzip tar gzip fail2ban ufw
```

### 2.3 設定 SSH 服務以支援多用戶
```bash
# 編輯 SSH 設定
sudo tee -a /etc/ssh/sshd_config << 'EOF'

# 多用戶連線優化
MaxAuthTries 6
MaxSessions 50
MaxStartups 30:30:100
ClientAliveInterval 300
ClientAliveCountMax 2

# 安全設定
PermitRootLogin no
PasswordAuthentication no
PubkeyAuthentication yes
AuthorizedKeysFile .ssh/authorized_keys
EOF

sudo systemctl restart ssh
```

### 2.4 設定防火牆
```bash
sudo ufw allow ssh
sudo ufw --force enable
```

### 2.5 設定 Fail2Ban (防止暴力破解)
```bash
sudo tee /etc/fail2ban/jail.local << 'EOF'
[sshd]
enabled = true
port = ssh
filter = sshd
logpath = /var/log/auth.log
maxretry = 5
bantime = 3600
EOF

sudo systemctl enable fail2ban
sudo systemctl start fail2ban
```

## 步驟 3: 批量建立受限制用戶

### 3.1 建立用戶管理腳本
```bash
# 建立用戶管理腳本
sudo tee /usr/local/bin/create-vscode-user.sh << 'EOF'
#!/bin/bash

if [ $# -ne 1 ]; then
    echo "Usage: $0 <username>"
    exit 1
fi

USERNAME=$1

# 建立用戶
sudo useradd -m -s /bin/bash $USERNAME
echo "User $USERNAME created"

# 建立 SSH 目錄
sudo mkdir -p /home/$USERNAME/.ssh
sudo chmod 700 /home/$USERNAME/.ssh
sudo chown $USERNAME:$USERNAME /home/$USERNAME/.ssh

# 建立受限制的 Shell 環境
sudo tee /home/$USERNAME/.bashrc > /dev/null << 'BASHRC_EOF'
# 基本環境設定
export HOME=/home/USERNAME_PLACEHOLDER
export USER=USERNAME_PLACEHOLDER
export LOGNAME=USERNAME_PLACEHOLDER
export PATH="/home/USERNAME_PLACEHOLDER/.local/bin:/usr/bin:/bin:/usr/sbin:/sbin"

# 確保在家目錄
cd /home/USERNAME_PLACEHOLDER 2>/dev/null || true

# 智能的目錄存取控制（只在互動式 shell 中啟用）
if [[ $- == *i* ]]; then
    restricted_cd() {
        local target_dir="$1"
        if [[ -z "$target_dir" ]]; then
            target_dir="$HOME"
        fi
        
        # 解析絕對路徑
        if [[ "$target_dir" = /* ]]; then
            # 絕對路徑 - 檢查是否在家目錄內
            if [[ "$target_dir" != "$HOME"* ]]; then
                echo "Access denied: You can only access your home directory"
                return 1
            fi
        else
            # 相對路徑 - 檢查結果是否會離開家目錄
            local full_path=$(realpath "$PWD/$target_dir" 2>/dev/null)
            if [[ $? -ne 0 ]] || [[ "$full_path" != "$HOME"* ]]; then
                echo "Access denied: You can only access your home directory"
                return 1
            fi
        fi
        
        builtin cd "$target_dir"
    }
    
    # 只在互動式 shell 中覆蓋 cd 命令
    alias cd='restricted_cd'
    
    # 歡迎訊息
    echo "Welcome to your restricted environment!"
    echo "You are limited to your home directory: $HOME"
    echo "Current users online: $(who | wc -l)"
fi

# 其他有用的別名
alias ls='ls --color=auto'
alias ll='ls -la'
alias la='ls -A'
alias l='ls -CF'
BASHRC_EOF

# 替換用戶名佔位符
sudo sed -i "s/USERNAME_PLACEHOLDER/$USERNAME/g" /home/$USERNAME/.bashrc
sudo chown $USERNAME:$USERNAME /home/$USERNAME/.bashrc

echo "User $USERNAME setup completed"
EOF

sudo chmod +x /usr/local/bin/create-vscode-user.sh
```

### 3.2 批量建立用戶 (範例：user01-user20)
```bash
# 建立 20 個用戶
for i in $(seq -w 1 20); do
    /usr/local/bin/create-vscode-user.sh user$i
done

# 或建立自定義用戶名
# /usr/local/bin/create-vscode-user.sh jameschan
# /usr/local/bin/create-vscode-user.sh alice
# /usr/local/bin/create-vscode-user.sh bob
```

### 3.3 批量設定 SSH 金鑰認證
```bash
# 在本機生成主要金鑰對
ssh-keygen -t rsa -b 4096 -f ~/.ssh/vm-users-key

# 為每個用戶設定公鑰 (在 VM 上執行)
PUBLIC_KEY="ssh-rsa AAAAB3NzaC1yc2EAAAA... your-public-key-here"

for i in $(seq -w 1 20); do
    echo "$PUBLIC_KEY" | sudo tee /home/user$i/.ssh/authorized_keys
    sudo chown user$i:user$i /home/user$i/.ssh/authorized_keys
    sudo chmod 600 /home/user$i/.ssh/authorized_keys
done
```

## 步驟 4: 實施多用戶安全限制

### 4.1 建立安全限制腳本
```bash
# 建立安全限制腳本
sudo tee /usr/local/bin/apply-security-restrictions.sh << 'EOF'
#!/bin/bash

echo "Applying security restrictions for all VS Code users..."

# 建立受限用戶群組
sudo groupadd vscode-users 2>/dev/null || true

# 將所有 user* 用戶加入群組
for user in $(ls /home | grep "^user[0-9]"); do
    sudo usermod -a -G vscode-users $user
done

# 限制存取敏感目錄
RESTRICTED_DIRS=(
    "/root"
    "/var/log"
    "/boot"
    "/home"  # 限制存取其他用戶的家目錄
)

for dir in "${RESTRICTED_DIRS[@]}"; do
    if [ -d "$dir" ]; then
        sudo setfacl -m g:vscode-users:--- "$dir"
    fi
done

# 限制存取敏感文件
SENSITIVE_FILES=(
    "/etc/passwd"
    "/etc/shadow"
    "/etc/group"
    "/etc/sudoers"
    "/etc/ssh/sshd_config"
)

for file in "${SENSITIVE_FILES[@]}"; do
    if [ -f "$file" ]; then
        sudo setfacl -m g:vscode-users:--- "$file"
    fi
done

# 允許存取必要的系統工具
REQUIRED_TOOLS=(
    "/usr/bin/node"
    "/usr/bin/npm"
    "/usr/bin/curl"
    "/usr/bin/wget"
    "/usr/bin/tar"
    "/usr/bin/gzip"
    "/usr/bin/unzip"
    "/usr/bin/ps"
    "/usr/bin/kill"
    "/usr/bin/find"
    "/usr/bin/grep"
    "/usr/bin/sed"
    "/usr/bin/awk"
    "/usr/bin/who"
    "/usr/bin/w"
    "/usr/bin/uptime"
    "/usr/bin/free"
    "/usr/bin/df"
)

for tool in "${REQUIRED_TOOLS[@]}"; do
    if [ -f "$tool" ]; then
        sudo setfacl -m g:vscode-users:rx "$tool"
    fi
done

# 允許存取必要的系統目錄
SYSTEM_DIRS=(
    "/usr"
    "/usr/bin"
    "/usr/lib"
    "/usr/lib64"
    "/lib"
    "/lib64"
    "/bin"
    "/tmp"
)

for dir in "${SYSTEM_DIRS[@]}"; do
    if [ -d "$dir" ]; then
        sudo setfacl -m g:vscode-users:rx "$dir"
    fi
done

# 允許存取 SSL 配置（VS Code Server 需要）
sudo setfacl -m g:vscode-users:rx /etc
sudo setfacl -m g:vscode-users:rx /etc/ssl
sudo setfacl -m g:vscode-users:r /etc/ssl/openssl.cnf

# 允許存取設備文件
sudo setfacl -m g:vscode-users:rx /dev
sudo setfacl -m g:vscode-users:rw /dev/null
sudo setfacl -m g:vscode-users:rw /dev/zero
sudo setfacl -m g:vscode-users:r /dev/urandom

# 確保用戶只能存取自己的家目錄
for user in $(ls /home | grep "^user[0-9]"); do
    sudo setfacl -m u:$user:rwx /home/$user
    sudo setfacl -R -m u:$user:rwx /home/$user/
    
    # 禁止存取其他用戶的家目錄
    for other_user in $(ls /home | grep "^user[0-9]"); do
        if [ "$user" != "$other_user" ]; then
            sudo setfacl -m u:$user:--- /home/$other_user
        fi
    done
done

echo "Security restrictions applied successfully"
EOF

sudo chmod +x /usr/local/bin/apply-security-restrictions.sh
```

### 4.2 執行安全限制
```bash
/usr/local/bin/apply-security-restrictions.sh
```

### 4.3 禁用 sudo 權限
```bash
sudo tee /etc/sudoers.d/restrict_vscode_users > /dev/null << 'EOF'
# 明確禁止 vscode-users 群組使用 sudo
%vscode-users ALL=(ALL) !ALL
EOF
```

### 4.4 設定資源限制
```bash
# 設定每個用戶的資源限制
sudo tee -a /etc/security/limits.conf << 'EOF'
# VS Code 用戶資源限制
@vscode-users soft nproc 100
@vscode-users hard nproc 150
@vscode-users soft nofile 4096
@vscode-users hard nofile 8192
@vscode-users soft fsize 10485760
@vscode-users hard fsize 20971520
@vscode-users soft cpu 30
@vscode-users hard cpu 60
EOF
```

## 步驟 5: 批量安裝 Amazon Q CLI

### 5.1 建立 Amazon Q CLI 下載腳本
```bash
# 建立批量下載腳本
sudo tee /usr/local/bin/download-q-cli-batch.sh << 'EOF'
#!/bin/bash

echo "Downloading Amazon Q CLI for all VS Code users..."

# 下載 Amazon Q CLI 到共享位置
cd /tmp
curl --proto '=https' --tlsv1.2 -sSf 'https://desktop-release.codewhisperer.us-east-1.amazonaws.com/latest/q-x86_64-linux.zip' -o 'q.zip'

if [ ! -f q.zip ]; then
    echo "Failed to download Amazon Q CLI"
    exit 1
fi

unzip q.zip

# 為每個用戶複製安裝文件
for user in $(ls /home | grep "^user[0-9]"); do
    echo "Preparing Q CLI installation files for user: $user"
    
    # 複製安裝文件到用戶目錄
    sudo -u $user cp -r /tmp/q /home/$user/
    echo "Installation files copied to /home/$user/q/"
done

# 清理共享的臨時文件
rm -rf /tmp/q.zip /tmp/q/

echo "Amazon Q CLI installation files prepared for all users"
echo "Each user needs to manually run: ./q/install.sh in their home directory"
EOF

sudo chmod +x /usr/local/bin/download-q-cli-batch.sh
```

### 5.2 執行批量下載
```bash
/usr/local/bin/download-q-cli-batch.sh
```

### 5.3 用戶手動安裝說明

每個用戶需要個別登入並手動執行安裝程序，因為 Amazon Q CLI 需要進行個人化的認證設定。

#### 用戶安裝步驟

1. **SSH 登入到各自的用戶帳號**
   ```bash
   # 每個用戶使用自己的帳號登入
   ssh -i ~/.ssh/vm-users-key user01@192.168.1.100
   ```

2. **執行安裝程式**
   ```bash
   # 在用戶家目錄執行
   cd ~
   ./q/install.sh
   ```

3. **互動式安裝流程**

   安裝程式會啟動互動式設定流程：

   **步驟 1：Shell 配置選擇**
   ```bash
   ? Do you want q to modify your shell config (you will have to manually do this otherwise)? ›
   ❯ Yes
     No
   ```
   **建議選擇 `Yes`**，讓安裝程式自動修改 shell 配置檔案。

   **步驟 2：登入方式選擇**
   ```bash
   ? Select login method ›
     Use for Free with Builder ID
   ❯ Use with Pro license
   ```
   選擇適合的登入方式：
   - **Use for Free with Builder ID**: 免費版本，使用 AWS Builder ID
   - **Use with Pro license**: 專業版本，使用企業 SSO 或 AWS 帳戶

   **步驟 3：輸入 Start URL（如選擇 Pro license）**
   ```bash
   ? Enter Start URL › https://your-org.awsapps.com/start
   ```
   輸入您組織的 AWS SSO Start URL。

   **步驟 4：選擇 AWS 區域**
   ```bash
   ? Enter Region › us-east-1
   ```
   選擇適當的 AWS 區域：
   - `us-east-1` (美國東部 - 維吉尼亞北部)
   - `eu-central-1` (歐洲 - 法蘭克福)

   **步驟 5：瀏覽器認證**
   ```bash
   Confirm the following code in the browser
   Code: LSRC-XPGB
   
   Open this URL: https://your-org.awsapps.com/start/#/device?user_code=LSRC-XPGB
   ▰▰▰▰▰▰▱ Logging in...
   ```
   
   **重要步驟**：
   - 複製顯示的 URL 到本地電腦的瀏覽器
   - 在瀏覽器中輸入顯示的驗證碼
   - 完成 AWS SSO 登入流程
   - 等待認證完成

   **步驟 6：安裝完成**
   ```bash
   Device authorized
   Logged in successfully
   ```

4. **重新載入環境變數**
   ```bash
   # 重新載入 shell 配置
   source ~/.bashrc
   ```

5. **驗證安裝**
   ```bash
   # 測試 Amazon Q CLI
   q --version
   q chat
   ```

### 5.4 批量驗證腳本
```bash
# 建立驗證腳本
sudo tee /usr/local/bin/verify-q-cli-batch.sh << 'EOF'
#!/bin/bash

echo "Verifying Amazon Q CLI installation for all users..."

for user in $(ls /home | grep "^user[0-9]"); do
    echo "Checking Q CLI for $user:"
    
    # 檢查安裝文件是否存在
    if [ -f "/home/$user/.local/bin/q" ]; then
        echo "  ✓ Q CLI binary found"
        # 檢查版本（需要用戶已完成認證）
        sudo -u $user /home/$user/.local/bin/q --version 2>/dev/null && echo "  ✓ Q CLI working" || echo "  ⚠ Q CLI needs authentication"
    else
        echo "  ✗ Q CLI not installed - user needs to run ./q/install.sh"
    fi
    echo
done
EOF

sudo chmod +x /usr/local/bin/verify-q-cli-batch.sh
```

### 5.5 管理員檢查安裝狀態
```bash
# 檢查所有用戶的安裝狀態
/usr/local/bin/verify-q-cli-batch.sh
```

### 5.6 重要注意事項

1. **個人化認證**：每個用戶必須個別完成認證流程，無法批量處理
2. **網路需求**：安裝過程需要存取外網進行認證
3. **瀏覽器需求**：用戶需要在本地電腦上使用瀏覽器完成 SSO 認證
4. **一次性設定**：每個用戶只需要執行一次安裝和認證流程
5. **清理安裝文件**：認證完成後，可以刪除 `~/q/` 目錄以節省空間

```bash
# 用戶完成安裝後可以清理安裝文件
rm -rf ~/q/
```

## VS Code Server 預安裝說明

### 為什麼需要預安裝 VS Code Server？

VS Code Remote SSH 的標準工作流程是自動下載並安裝 VS Code Server，但在 20 人同時使用的環境中會帶來問題：

- **網路擁塞**：20 人同時下載 ~65MB，總計 1.3GB 流量
- **連接失敗**：首次連接需要 2-10 分鐘，成功率僅 70-80%
- **用戶體驗差**：長時間等待和可能的連接中斷

**預安裝的優勢**：
- 連接時間從 2-10 分鐘縮短到 5-15 秒
- 成功率提升到 95%+
- 支援離線環境，減少外網依賴
- 統一版本管理，符合企業需求

因此，對於多用戶環境，我們採用預安裝方式以確保最佳的用戶體驗和系統穩定性。

---

## 步驟 6: 批量預安裝 VS Code Server

### 6.1 建立 VS Code Server 批量安裝腳本
```bash
# 建立批量安裝腳本
sudo tee /usr/local/bin/install-vscode-server-batch.sh << 'EOF'
#!/bin/bash

echo "Installing VS Code Server for all users..."

# 獲取最新版本
VSCODE_VERSION=$(curl -s https://api.github.com/repos/microsoft/vscode/releases/latest | grep '"tag_name"' | cut -d'"' -f4)

if [ -z "$VSCODE_VERSION" ]; then
    VSCODE_VERSION="1.102.3"
    echo "Using default version: $VSCODE_VERSION"
else
    echo "Latest version: $VSCODE_VERSION"
fi

# 下載 VS Code Server 到共享位置
cd /tmp
echo "Downloading VS Code Server..."
wget -O vscode-server.tar.gz "https://update.code.visualstudio.com/$VSCODE_VERSION/server-linux-x64/stable"

if [ ! -f vscode-server.tar.gz ]; then
    echo "Failed to download VS Code Server"
    exit 1
fi

echo "VS Code Server downloaded successfully"

# 為每個用戶安裝
for user in $(ls /home | grep "^user[0-9]"); do
    echo "Installing VS Code Server for user: $user"
    
    # 建立用戶的 VS Code Server 目錄
    sudo -u $user mkdir -p /home/$user/.vscode-server/bin/$VSCODE_VERSION
    
    # 解壓縮到用戶目錄
    sudo tar -xzf vscode-server.tar.gz -C /home/$user/.vscode-server/bin/$VSCODE_VERSION --strip-components=1
    sudo chown -R $user:$user /home/$user/.vscode-server/bin/$VSCODE_VERSION
    
    # 建立版本標記
    echo $VSCODE_VERSION | sudo -u $user tee /home/$user/.vscode-server/bin/$VSCODE_VERSION/.version > /dev/null
    
    echo "VS Code Server installed for $user"
done

# 清理
rm -f vscode-server.tar.gz

echo "VS Code Server installation completed for all users"
EOF

sudo chmod +x /usr/local/bin/install-vscode-server-batch.sh
```

### 6.2 執行批量安裝
```bash
/usr/local/bin/install-vscode-server-batch.sh
```

### 6.3 修復所有用戶的 VS Code Server 權限
```bash
# 建立權限修復腳本
sudo tee /usr/local/bin/fix-vscode-permissions.sh << 'EOF'
#!/bin/bash

echo "Fixing VS Code Server permissions for all users..."

for user in $(ls /home | grep "^user[0-9]"); do
    echo "Fixing permissions for user: $user"
    
    sudo chown -R $user:$user /home/$user/.vscode-server/
    sudo chmod -R u+rwX /home/$user/.vscode-server/
    sudo find /home/$user/.vscode-server/ -name 'code-server' -exec chmod +x {} \;
    sudo find /home/$user/.vscode-server/ -name 'node' -exec chmod +x {} \;
done

echo "Permissions fixed for all users"
EOF

sudo chmod +x /usr/local/bin/fix-vscode-permissions.sh
/usr/local/bin/fix-vscode-permissions.sh
```

### 6.4 建立 VS Code Server 更新腳本
```bash
# 建立定期更新腳本
sudo tee /usr/local/bin/update-vscode-server.sh << 'EOF'
#!/bin/bash

LOG_FILE="/var/log/vscode-server-update.log"

echo "$(date): Starting VS Code Server update" | tee -a $LOG_FILE

# 獲取最新版本
LATEST_VERSION=$(curl -s https://api.github.com/repos/microsoft/vscode/releases/latest | grep '"tag_name"' | cut -d'"' -f4)

if [ -z "$LATEST_VERSION" ]; then
    echo "$(date): Failed to get latest version" | tee -a $LOG_FILE
    exit 1
fi

echo "$(date): Latest version: $LATEST_VERSION" | tee -a $LOG_FILE

# 檢查是否需要更新
NEED_UPDATE=false
for user in $(ls /home | grep "^user[0-9]"); do
    CURRENT_VERSION=$(ls /home/$user/.vscode-server/bin/ 2>/dev/null | head -1)
    if [ "$CURRENT_VERSION" != "$LATEST_VERSION" ]; then
        NEED_UPDATE=true
        break
    fi
done

if [ "$NEED_UPDATE" = false ]; then
    echo "$(date): All users already have the latest version" | tee -a $LOG_FILE
    exit 0
fi

# 下載最新版本
cd /tmp
echo "$(date): Downloading VS Code Server $LATEST_VERSION" | tee -a $LOG_FILE
wget -O vscode-server-latest.tar.gz "https://update.code.visualstudio.com/$LATEST_VERSION/server-linux-x64/stable"

if [ ! -f vscode-server-latest.tar.gz ]; then
    echo "$(date): Failed to download VS Code Server" | tee -a $LOG_FILE
    exit 1
fi

# 為每個用戶更新
for user in $(ls /home | grep "^user[0-9]"); do
    echo "$(date): Updating VS Code Server for $user" | tee -a $LOG_FILE
    
    # 備份舊版本（保留最近一個版本）
    OLD_VERSIONS=$(ls /home/$user/.vscode-server/bin/ 2>/dev/null | grep -v "$LATEST_VERSION" | head -n -1)
    for old_ver in $OLD_VERSIONS; do
        rm -rf /home/$user/.vscode-server/bin/$old_ver
    done
    
    # 安裝新版本
    sudo -u $user mkdir -p /home/$user/.vscode-server/bin/$LATEST_VERSION
    sudo tar -xzf vscode-server-latest.tar.gz -C /home/$user/.vscode-server/bin/$LATEST_VERSION --strip-components=1
    sudo chown -R $user:$user /home/$user/.vscode-server/bin/$LATEST_VERSION
    
    # 建立版本標記
    echo $LATEST_VERSION | sudo -u $user tee /home/$user/.vscode-server/bin/$LATEST_VERSION/.version > /dev/null
    
    # 修復權限
    sudo chmod -R u+rwX /home/$user/.vscode-server/bin/$LATEST_VERSION
    sudo find /home/$user/.vscode-server/bin/$LATEST_VERSION -name 'code-server' -exec chmod +x {} \;
    sudo find /home/$user/.vscode-server/bin/$LATEST_VERSION -name 'node' -exec chmod +x {} \;
done

# 清理
rm -f vscode-server-latest.tar.gz

echo "$(date): VS Code Server update completed" | tee -a $LOG_FILE
EOF

sudo chmod +x /usr/local/bin/update-vscode-server.sh

### 6.5 驗證安裝和測試更新
```bash
# 測試幾個用戶的 VS Code Server
for user in user01 user02 user03; do
    echo "Testing VS Code Server for $user:"
    VSCODE_DIR=$(sudo -u $user ls /home/$user/.vscode-server/bin/ | head -1)
    sudo -u $user /home/$user/.vscode-server/bin/$VSCODE_DIR/bin/code-server --version
done

# 測試更新腳本
echo "Testing VS Code Server update script:"
/usr/local/bin/update-vscode-server.sh

# 檢查更新日誌
tail -10 /var/log/vscode-server-update.log
```

### 6.6 VS Code Server 版本管理最佳實踐

```bash
# 建立版本檢查腳本
sudo tee /usr/local/bin/check-vscode-versions.sh << 'EOF'
#!/bin/bash

echo "=== VS Code Server 版本檢查 ==="
echo "檢查時間: $(date)"
echo

# 獲取最新可用版本
LATEST_VERSION=$(curl -s https://api.github.com/repos/microsoft/vscode/releases/latest | grep '"tag_name"' | cut -d'"' -f4)
echo "最新版本: $LATEST_VERSION"
echo

# 檢查每個用戶的版本
echo "用戶版本檢查:"
for user in $(ls /home | grep "^user[0-9]" | head -5); do
    INSTALLED_VERSIONS=$(ls /home/$user/.vscode-server/bin/ 2>/dev/null | tr '\n' ' ')
    echo "  $user: $INSTALLED_VERSIONS"
done

echo
echo "版本統計:"
ls /home/user*/.vscode-server/bin/ 2>/dev/null | sort | uniq -c | sort -nr

echo
echo "磁碟使用量:"
du -sh /home/user*/.vscode-server/ 2>/dev/null | head -5
EOF

sudo chmod +x /usr/local/bin/check-vscode-versions.sh
```

## 步驟 7: 設定 VS Code Remote SSH (本地電腦設定)

> **注意**：以下步驟需要在**用戶的本地電腦**上執行，不是在 Ubuntu VM 上。

### 7.1 本機 SSH 設定 (支援多用戶)
在**本機**的 `~/.ssh/config` 文件中添加：
```
# Ubuntu VM 多用戶設定
Host ubuntu-vm-user01
    HostName 192.168.1.100
    User user01
    IdentityFile ~/.ssh/vm-users-key
    StrictHostKeyChecking no
    ServerAliveInterval 60
    ServerAliveCountMax 3

Host ubuntu-vm-user02
    HostName 192.168.1.100
    User user02
    IdentityFile ~/.ssh/vm-users-key
    StrictHostKeyChecking no
    ServerAliveInterval 60
    ServerAliveCountMax 3

# 可以繼續添加更多用戶...
# 或使用通配符設定
Host ubuntu-vm-user*
    HostName 192.168.1.100
    IdentityFile ~/.ssh/vm-users-key
    StrictHostKeyChecking no
    ServerAliveInterval 60
    ServerAliveCountMax 3
```

### 7.2 建立連接測試腳本 (本地電腦)
```bash
# 在本機建立測試腳本
cat > ~/test-vm-connections.sh << 'EOF'
#!/bin/bash

VM_IP="192.168.1.100"
KEY_FILE="~/.ssh/vm-users-key"

echo "Testing connections to Ubuntu VM users..."

for i in $(seq -w 1 20); do
    user="user$i"
    echo -n "Testing $user: "
    
    if ssh -i $KEY_FILE -o ConnectTimeout=5 -o BatchMode=yes $user@$VM_IP "echo 'OK'" 2>/dev/null; then
        echo "✓ Connected"
    else
        echo "✗ Failed"
    fi
done
EOF

chmod +x ~/test-vm-connections.sh
```

### 7.3 VS Code 多用戶連接設定 (本地電腦)
1. 在**本地電腦**開啟 VS Code
2. 按 `Cmd+Shift+P` (macOS) 或 `Ctrl+Shift+P` (Windows/Linux)
3. 輸入 "Remote-SSH: Connect to Host"
4. 選擇對應的用戶主機 (例如 "ubuntu-vm-user01")

### 7.4 VS Code Explorer 限制設定 (Ubuntu VM 上的全域設定)

> **注意**：以下步驟需要在 **Ubuntu VM** 上執行，為所有用戶建立統一的 VS Code 設定。

每個用戶連接後，VS Code 會自動建立個人設定。如需統一設定，可在 VM 上建立全域設定：

```bash
# 建立全域 VS Code 設定腳本
sudo tee /usr/local/bin/setup-vscode-settings.sh << 'EOF'
#!/bin/bash

SETTINGS_JSON='{
    "files.exclude": {
        "/etc/**": true,
        "/root/**": true,
        "/var/**": true,
        "/usr/**": true,
        "/opt/**": true,
        "/boot/**": true,
        "/sys/**": true,
        "/proc/**": true,
        "/dev/**": true,
        "/run/**": true,
        "/tmp/**": true,
        "/srv/**": true,
        "/mnt/**": true,
        "/media/**": true,
        "/lib/**": true,
        "/bin/**": true,
        "/sbin/**": true
    },
    "search.exclude": {
        "/etc/**": true,
        "/root/**": true,
        "/var/**": true,
        "/usr/**": true,
        "/opt/**": true,
        "/boot/**": true,
        "/sys/**": true,
        "/proc/**": true,
        "/dev/**": true,
        "/run/**": true,
        "/tmp/**": true,
        "/srv/**": true,
        "/mnt/**": true,
        "/media/**": true,
        "/lib/**": true,
        "/bin/**": true,
        "/sbin/**": true
    },
    "terminal.integrated.cwd": "~",
    "terminal.integrated.defaultProfile.linux": "bash"
}'

for user in $(ls /home | grep "^user[0-9]"); do
    echo "Setting up VS Code settings for $user"
    
    sudo -u $user mkdir -p /home/$user/.vscode-server/data/User
    echo "$SETTINGS_JSON" | sudo -u $user tee /home/$user/.vscode-server/data/User/settings.json > /dev/null
done

echo "VS Code settings applied to all users"
EOF

sudo chmod +x /usr/local/bin/setup-vscode-settings.sh
/usr/local/bin/setup-vscode-settings.sh
```

## 步驟 8: 測試和驗證

### 8.1 系統資源監控
```bash
# 建立系統監控腳本
sudo tee /usr/local/bin/monitor-system.sh << 'EOF'
#!/bin/bash

echo "=== 系統資源監控 ==="
echo "時間: $(date)"
echo

echo "=== CPU 使用率 ==="
top -bn1 | grep "Cpu(s)" | awk '{print $2 $3 $4 $5 $6 $7 $8}'

echo
echo "=== 記憶體使用情況 ==="
free -h

echo
echo "=== 磁碟使用情況 ==="
df -h /

echo
echo "=== 當前登入用戶 ==="
who | wc -l
who

echo
echo "=== 活躍的 VS Code Server 進程 ==="
ps aux | grep code-server | grep -v grep | wc -l

echo
echo "=== 網路連接統計 ==="
ss -tuln | grep :22

echo
echo "=== 系統負載 ==="
uptime

echo
echo "=== 前 10 個消耗記憶體的進程 ==="
ps aux --sort=-%mem | head -11
EOF

sudo chmod +x /usr/local/bin/monitor-system.sh
```

### 8.2 測試多用戶連接
```bash
# 測試 SSH 連接
for i in $(seq -w 1 5); do
    echo "Testing user$i SSH connection:"
    ssh -i ~/.ssh/vm-users-key -o ConnectTimeout=5 user$i@192.168.1.100 "whoami && pwd && q --version" || echo "Connection failed"
    echo "---"
done
```

### 8.3 測試安全限制
```bash
# 在 VM 上測試安全限制
sudo tee /usr/local/bin/test-security.sh << 'EOF'
#!/bin/bash

echo "=== 安全限制測試 ==="

for user in user01 user02 user03; do
    echo "Testing security for $user:"
    
    echo -n "  Access to /etc/passwd: "
    sudo -u $user cat /etc/passwd 2>&1 | head -1 | grep -q "Permission denied" && echo "✓ BLOCKED" || echo "✗ ALLOWED"
    
    echo -n "  Access to /root: "
    sudo -u $user ls /root 2>&1 | head -1 | grep -q "Permission denied" && echo "✓ BLOCKED" || echo "✗ ALLOWED"
    
    echo -n "  Access to other user's home: "
    sudo -u $user ls /home/user02 2>&1 | head -1 | grep -q "Permission denied" && echo "✓ BLOCKED" || echo "✗ ALLOWED"
    
    echo -n "  Can access own home: "
    sudo -u $user ls /home/$user > /dev/null 2>&1 && echo "✓ ALLOWED" || echo "✗ BLOCKED"
    
    echo
done
EOF

sudo chmod +x /usr/local/bin/test-security.sh
/usr/local/bin/test-security.sh
```

### 8.4 效能基準測試
```bash
# 建立效能測試腳本
sudo tee /usr/local/bin/performance-test.sh << 'EOF'
#!/bin/bash

echo "=== 效能基準測試 ==="

echo "1. 測試同時啟動多個 VS Code Server..."
start_time=$(date +%s)

# 模擬 5 個用戶同時啟動 VS Code Server
for i in $(seq 1 5); do
    user="user$(printf "%02d" $i)"
    echo "Starting VS Code Server for $user..."
    
    sudo -u $user bash -c "
        VSCODE_DIR=\$(ls /home/$user/.vscode-server/bin/ | head -1)
        timeout 10s /home/$user/.vscode-server/bin/\$VSCODE_DIR/bin/code-server --version > /dev/null 2>&1
    " &
done

wait
end_time=$(date +%s)
echo "所有 VS Code Server 啟動完成，耗時: $((end_time - start_time)) 秒"

echo
echo "2. 記憶體使用情況:"
free -h

echo
echo "3. CPU 負載:"
uptime

echo
echo "4. 磁碟 I/O 測試:"
dd if=/dev/zero of=/tmp/test_file bs=1M count=100 2>&1 | grep copied

rm -f /tmp/test_file
EOF

sudo chmod +x /usr/local/bin/performance-test.sh
```

## 步驟 9: 系統維護和監控

### 9.1 建立自動化維護腳本
```bash
# 建立每日維護腳本
sudo tee /usr/local/bin/daily-maintenance.sh << 'EOF'
#!/bin/bash

LOG_FILE="/var/log/vscode-maintenance.log"

echo "$(date): Starting daily maintenance" >> $LOG_FILE

# 清理臨時文件
find /tmp -type f -atime +1 -delete 2>/dev/null
echo "$(date): Cleaned temporary files" >> $LOG_FILE

# 清理用戶的 VS Code 日誌
for user in $(ls /home | grep "^user[0-9]"); do
    find /home/$user/.vscode-server -name "*.log" -mtime +7 -delete 2>/dev/null
done
echo "$(date): Cleaned VS Code logs" >> $LOG_FILE

# 檢查 VS Code Server 版本一致性
LATEST_VERSION=$(curl -s https://api.github.com/repos/microsoft/vscode/releases/latest | grep '"tag_name"' | cut -d'"' -f4)
OUTDATED_USERS=0
for user in $(ls /home | grep "^user[0-9]"); do
    CURRENT_VERSION=$(ls /home/$user/.vscode-server/bin/ 2>/dev/null | head -1)
    if [ "$CURRENT_VERSION" != "$LATEST_VERSION" ]; then
        OUTDATED_USERS=$((OUTDATED_USERS + 1))
    fi
done

if [ $OUTDATED_USERS -gt 0 ]; then
    echo "$(date): WARNING - $OUTDATED_USERS users have outdated VS Code Server (latest: $LATEST_VERSION)" >> $LOG_FILE
fi

# 檢查磁碟使用量
DISK_USAGE=$(df / | tail -1 | awk '{print $5}' | sed 's/%//')
if [ $DISK_USAGE -gt 80 ]; then
    echo "$(date): WARNING - Disk usage is ${DISK_USAGE}%" >> $LOG_FILE
fi

# 檢查記憶體使用量
MEM_USAGE=$(free | grep Mem | awk '{printf("%.0f", $3/$2 * 100.0)}')
if [ $MEM_USAGE -gt 90 ]; then
    echo "$(date): WARNING - Memory usage is ${MEM_USAGE}%" >> $LOG_FILE
fi

# 檢查活躍的 VS Code Server 進程數
VSCODE_PROCESSES=$(ps aux | grep code-server | grep -v grep | wc -l)
echo "$(date): Active VS Code Server processes: $VSCODE_PROCESSES" >> $LOG_FILE

echo "$(date): Daily maintenance completed" >> $LOG_FILE
EOF

sudo chmod +x /usr/local/bin/daily-maintenance.sh

# 設定 cron job
echo "0 2 * * * /usr/local/bin/daily-maintenance.sh" | sudo crontab -
echo "0 3 1 * * /usr/local/bin/update-vscode-server.sh" | sudo crontab -
```

### 9.2 建立用戶管理工具
```bash
# 建立用戶管理腳本
sudo tee /usr/local/bin/manage-vscode-users.sh << 'EOF'
#!/bin/bash

case "$1" in
    "add")
        if [ -z "$2" ]; then
            echo "Usage: $0 add <username>"
            exit 1
        fi
        /usr/local/bin/create-vscode-user.sh "$2"
        /usr/local/bin/apply-security-restrictions.sh
        echo "User $2 added successfully"
        ;;
    "remove")
        if [ -z "$2" ]; then
            echo "Usage: $0 remove <username>"
            exit 1
        fi
        sudo userdel -r "$2"
        echo "User $2 removed successfully"
        ;;
    "list")
        echo "VS Code users:"
        ls /home | grep "^user[0-9]" | sort
        ;;
    "status")
        echo "=== VS Code 環境狀態 ==="
        /usr/local/bin/monitor-system.sh
        ;;
    *)
        echo "Usage: $0 {add|remove|list|status} [username]"
        exit 1
        ;;
esac
EOF

sudo chmod +x /usr/local/bin/manage-vscode-users.sh
```

## 故障排除

### 常見問題

1. **多用戶 SSH 連接失敗**
   - 檢查 VM IP 位址和網路連接
   - 確認 SSH 服務運行：`sudo systemctl status ssh`
   - 檢查 SSH 設定：`sudo sshd -T | grep -i max`
   - 檢查防火牆設定：`sudo ufw status`
   - 查看 SSH 日誌：`sudo tail -f /var/log/auth.log`

2. **系統效能問題**
   - 監控系統資源：`/usr/local/bin/monitor-system.sh`
   - 檢查記憶體使用：`free -h`
   - 檢查 CPU 負載：`top`
   - 檢查磁碟空間：`df -h`
   - 檢查交換空間：`swapon -s`

3. **VS Code Server 啟動緩慢**
   - 檢查是否已預安裝：`ls ~/.vscode-server/bin/`
   - 檢查網路連接：`curl -I https://update.code.visualstudio.com`
   - 重新安裝：`/usr/local/bin/install-vscode-server-batch.sh`
   - 修復權限：`/usr/local/bin/fix-vscode-permissions.sh`

4. **用戶權限問題**
   - 重新套用安全限制：`/usr/local/bin/apply-security-restrictions.sh`
   - 檢查 ACL 設定：`getfacl /home/user01`
   - 測試安全限制：`/usr/local/bin/test-security.sh`

5. **資源不足問題**
   - 增加 VM 記憶體和 CPU
   - 清理臨時文件：`/usr/local/bin/daily-maintenance.sh`
   - 限制同時連線數量
   - 監控資源使用：`htop`

### 效能調優建議

1. **記憶體優化**
   ```bash
   # 調整 swappiness
   echo 'vm.swappiness=10' | sudo tee -a /etc/sysctl.conf
   
   # 清理記憶體快取
   sudo sync && echo 3 | sudo tee /proc/sys/vm/drop_caches
   ```

2. **磁碟 I/O 優化**
   ```bash
   # 使用 SSD 並啟用 TRIM
   sudo fstrim -av
   
   # 調整 I/O 排程器
   echo mq-deadline | sudo tee /sys/block/sda/queue/scheduler
   ```

3. **網路優化**
   ```bash
   # 調整 TCP 參數
   sudo tee -a /etc/sysctl.conf << 'EOF'
   net.core.rmem_max = 16777216
   net.core.wmem_max = 16777216
   net.ipv4.tcp_rmem = 4096 87380 16777216
   net.ipv4.tcp_wmem = 4096 65536 16777216
   EOF
   ```

## 使用 Amazon Q CLI 自動化部署

### 多用戶環境自動化 Prompt 範本

您可以使用以下 prompt 來請求 Amazon Q CLI 協助自動化部署：

```
請幫我建立一個自動化腳本來部署支援 20 人同時使用的 VS Code Remote SSH 環境到 Ubuntu VM，需求如下：

1. 目標環境：Ubuntu 22.04 LTS Server VM
2. VM 規格：16-20 核心 CPU，64-80GB RAM，500GB SSD
3. 批量建立受限制用戶：user01-user20
4. 系統優化：
   - 支援高並發 SSH 連線 (MaxSessions 50)
   - 記憶體和 CPU 調優
   - 網路參數優化
   - 設定 Fail2Ban 防護
5. 安全限制：
   - 使用 ACL 和群組權限管理
   - 限制用戶只能存取自己的家目錄
   - 禁止存取敏感系統文件
   - 設定資源使用限制
6. 批量安裝軟體：
   - Amazon Q CLI (所有用戶)
   - VS Code Server 預安裝 (所有用戶)
   - 必要的開發工具
7. 監控和維護：
   - 系統資源監控腳本
   - 自動化維護任務
   - 用戶管理工具
   - 效能測試工具

請提供完整的 bash 腳本，包含：
- 錯誤處理和回滾機制
- 進度顯示和日誌記錄
- 冪等性設計（可重複執行）
- 效能基準測試
- 安全驗證測試

額外需求：
- 支援自定義用戶數量和命名規則
- 提供資源使用量預估
- 包含災難恢復計劃
- 支援批量用戶管理操作
```

### 進階多用戶管理 Prompt

```
基於上述的多用戶 VS Code Remote SSH 環境，請幫我建立一個企業級的管理系統：

1. 用戶生命週期管理：
   - 批量用戶建立/刪除/暫停
   - 用戶權限動態調整
   - 用戶活動監控和審計
   - 自動清理非活躍用戶

2. 資源管理和調度：
   - 動態資源分配
   - 負載平衡和限流
   - 自動擴展機制
   - 資源使用報告

3. 安全和合規：
   - 多層安全防護
   - 存取日誌和審計
   - 合規性檢查
   - 安全事件響應

4. 監控和告警：
   - 實時系統監控
   - 效能指標收集
   - 自動告警機制
   - 容量規劃建議

5. 自動化運維：
   - CI/CD 整合
   - 配置管理 (Ansible/Terraform)
   - 備份和恢復自動化
   - 版本更新管理

6. 用戶體驗優化：
   - 連接品質監控
   - 效能調優建議
   - 故障自動診斷
   - 用戶支援工具

請提供完整的實作方案，包含：
- 架構設計文件
- 所有必要的腳本和配置
- 部署和維護手冊
- 監控儀表板設計
- 災難恢復程序
```

### 客製化大規模部署 Prompt

```
我需要為我的組織部署一個大規模的 VS Code Remote SSH 環境：

環境需求：
- 用戶數量：[50-100 人]
- VM 規格：[指定具體需求]
- 網路環境：[內網/混合雲/多地點]
- 安全要求：[企業安全政策]
- 合規需求：[GDPR/SOX/其他]
- 整合需求：[LDAP/AD/SSO]

技術需求：
- 高可用性設計
- 負載均衡和故障轉移
- 資料備份和災難恢復
- 監控和日誌管理
- 自動化部署和更新

請幫我：
1. 設計可擴展的架構方案
2. 建立完整的部署自動化
3. 提供運維管理工具
4. 建立監控和告警系統
5. 制定安全和合規策略
6. 提供成本優化建議
7. 建立用戶培訓材料

請考慮：
- 多租戶隔離
- 效能和可擴展性
- 安全和合規
- 運維複雜度
- 總體擁有成本 (TCO)
```

### 故障排除自動化 Prompt

```
請幫我建立一個智能的故障排除系統，用於多用戶 VS Code Remote SSH 環境：

1. 自動診斷系統：
   - 連接問題診斷
   - 效能問題分析
   - 權限問題檢測
   - 資源不足預警

2. 自動修復機制：
   - 常見問題自動修復
   - 服務自動重啟
   - 權限自動修復
   - 資源自動清理

3. 監控和告警：
   - 實時健康檢查
   - 異常行為檢測
   - 預測性維護
   - 智能告警過濾

4. 用戶支援工具：
   - 自助診斷工具
   - 問題報告系統
   - 解決方案知識庫
   - 用戶指導系統

5. 運維工具：
   - 批量操作工具
   - 配置驗證工具
   - 效能調優建議
   - 容量規劃工具

請提供：
- 完整的診斷腳本
- 自動修復程序
- 監控配置
- 告警規則
- 用戶支援工具
- 運維手冊
```

---

**重要提醒：**

### 資源規劃建議
- **20 人同時使用**：建議 VM 規格為 16-20 核心 CPU，64-80GB RAM，500GB SSD
- **網路頻寬**：建議至少 100Mbps 上行頻寬
- **監控**：定期使用 `/usr/local/bin/monitor-system.sh` 監控系統狀態
- **維護**：每日執行 `/usr/local/bin/daily-maintenance.sh` 進行系統維護

### 擴展性考量
- 如需支援更多用戶，可考慮使用多台 VM 進行負載分散
- 建議建立用戶使用量監控，以便及時調整資源配置
- 定期備份用戶資料和系統配置

### 安全注意事項
- 定期更新系統和軟體套件
- 監控用戶活動和系統日誌
- 定期檢查和更新安全設定
- 遵循組織的安全政策和合規要求

---

## 附錄 A: SSH 帳號密碼認證修改指南

### 概述

本附錄說明如何將現有的 SSH 金鑰認證方式改為帳號密碼認證方式，以便在 VS Code Remote SSH 中使用。

### 需要修改的章節

#### A.1 步驟 2.3 - SSH 服務設定修改

**原始設定**：
```bash
# 編輯 SSH 設定
sudo tee -a /etc/ssh/sshd_config << 'EOF'

# 多用戶連線優化
MaxAuthTries 6
MaxSessions 50
MaxStartups 30:30:100
ClientAliveInterval 300
ClientAliveCountMax 2

# 安全設定
PermitRootLogin no
PasswordAuthentication no  # ← 需要修改
PubkeyAuthentication yes
AuthorizedKeysFile .ssh/authorized_keys
EOF
```

**修改為密碼認證**：
```bash
# 編輯 SSH 設定
sudo tee -a /etc/ssh/sshd_config << 'EOF'

# 多用戶連線優化
MaxAuthTries 6
MaxSessions 50
MaxStartups 30:30:100
ClientAliveInterval 300
ClientAliveCountMax 2

# 安全設定
PermitRootLogin no
PasswordAuthentication yes  # ← 啟用密碼認證
PubkeyAuthentication yes    # ← 可以同時保留金鑰認證
AuthorizedKeysFile .ssh/authorized_keys

# 密碼認證額外安全設定
MaxAuthTries 3              # 限制密碼嘗試次數
LoginGraceTime 60           # 登入超時時間
EOF

sudo systemctl restart ssh
```

#### A.2 步驟 3.2 - 用戶建立和密碼設定

**原始腳本修改**：

在 `create-vscode-user.sh` 腳本中添加密碼設定：

```bash
#!/bin/bash

if [ $# -ne 2 ]; then
    echo "Usage: $0 <username> <password>"
    exit 1
fi

USERNAME=$1
PASSWORD=$2

# 建立用戶並設定密碼
sudo useradd -m -s /bin/bash $USERNAME
echo "$USERNAME:$PASSWORD" | sudo chpasswd
echo "User $USERNAME created with password"

# 建立 SSH 目錄（保留原有設定）
sudo mkdir -p /home/$USERNAME/.ssh
sudo chmod 700 /home/$USERNAME/.ssh
sudo chown $USERNAME:$USERNAME /home/$USERNAME/.ssh

# 其餘設定保持不變...
```

**批量建立用戶範例**：
```bash
# 建立 20 個用戶並設定密碼
for i in $(seq -w 1 20); do
    # 可以使用統一密碼或個別密碼
    PASSWORD="User${i}@2024"  # 或使用更安全的密碼生成
    /usr/local/bin/create-vscode-user.sh user$i $PASSWORD
    echo "user$i password: $PASSWORD" >> /tmp/user_passwords.txt
done

# 安全地分發密碼給用戶
sudo chmod 600 /tmp/user_passwords.txt
```

#### A.3 步驟 3.3 - 移除 SSH 金鑰設定

**原始章節**：
```bash
### 3.3 批量設定 SSH 金鑰認證
# 在本機生成主要金鑰對
ssh-keygen -t rsa -b 4096 -f ~/.ssh/vm-users-key

# 為每個用戶設定公鑰 (在 VM 上執行)
PUBLIC_KEY="ssh-rsa AAAAB3NzaC1yc2EAAAA... your-public-key-here"

for i in $(seq -w 1 20); do
    echo "$PUBLIC_KEY" | sudo tee /home/user$i/.ssh/authorized_keys
    sudo chown user$i:user$i /home/user$i/.ssh/authorized_keys
    sudo chmod 600 /home/user$i/.ssh/authorized_keys
done
```

**修改為**：
```bash
### 3.3 用戶密碼管理

# 建立密碼管理腳本
sudo tee /usr/local/bin/manage-user-passwords.sh << 'EOF'
#!/bin/bash

case "$1" in
    "generate")
        # 為所有用戶生成隨機密碼
        for user in $(ls /home | grep "^user[0-9]"); do
            PASSWORD=$(openssl rand -base64 12)
            echo "$user:$PASSWORD" | sudo chpasswd
            echo "$user:$PASSWORD" >> /tmp/new_passwords.txt
        done
        echo "Passwords generated and saved to /tmp/new_passwords.txt"
        ;;
    "change")
        if [ -z "$2" ] || [ -z "$3" ]; then
            echo "Usage: $0 change <username> <new_password>"
            exit 1
        fi
        echo "$2:$3" | sudo chpasswd
        echo "Password changed for user $2"
        ;;
    *)
        echo "Usage: $0 {generate|change} [username] [password]"
        exit 1
        ;;
esac
EOF

sudo chmod +x /usr/local/bin/manage-user-passwords.sh
```

#### A.4 步驟 7.1 - 本機 SSH 設定修改

**原始設定**：
```bash
# Ubuntu VM 多用戶設定
Host ubuntu-vm-user01
    HostName 192.168.1.100
    User user01
    IdentityFile ~/.ssh/vm-users-key  # ← 移除此行
    StrictHostKeyChecking no
    ServerAliveInterval 60
    ServerAliveCountMax 3
```

**修改為密碼認證**：
```bash
# Ubuntu VM 多用戶設定 (密碼認證)
Host ubuntu-vm-user01
    HostName 192.168.1.100
    User user01
    PreferredAuthentications password
    StrictHostKeyChecking no
    ServerAliveInterval 60
    ServerAliveCountMax 3

Host ubuntu-vm-user02
    HostName 192.168.1.100
    User user02
    PreferredAuthentications password
    StrictHostKeyChecking no
    ServerAliveInterval 60
    ServerAliveCountMax 3

# 通配符設定
Host ubuntu-vm-user*
    HostName 192.168.1.100
    PreferredAuthentications password
    StrictHostKeyChecking no
    ServerAliveInterval 60
    ServerAliveCountMax 3
```

### A.5 VS Code Remote SSH 密碼認證設定

#### A.5.1 VS Code 設定檔修改

在 VS Code 的設定中，需要確保支援密碼認證：

**方法 1：VS Code 設定檔**
```json
{
    "remote.SSH.showLoginTerminal": true,
    "remote.SSH.useLocalServer": false,
    "remote.SSH.remotePlatform": {
        "ubuntu-vm-user01": "linux",
        "ubuntu-vm-user02": "linux"
    }
}
```

**方法 2：命令面板設定**
1. 在 VS Code 中按 `Cmd+Shift+P` (macOS) 或 `Ctrl+Shift+P` (Windows/Linux)
2. 輸入 "Remote-SSH: Connect to Host"
3. 選擇主機後，VS Code 會提示輸入密碼
4. 輸入對應用戶的密碼

#### A.5.2 連接流程

使用密碼認證時的連接流程：

1. **選擇主機**：在 VS Code 中選擇 "ubuntu-vm-user01"
2. **輸入密碼**：VS Code 會彈出密碼輸入框
3. **建立連接**：輸入正確密碼後建立 SSH 連接
4. **啟動 VS Code Server**：自動啟動遠端 VS Code Server

### A.6 安全考量和最佳實踐

#### A.6.1 密碼安全策略

```bash
# 設定密碼複雜度要求
sudo tee -a /etc/security/pwquality.conf << 'EOF'
# 密碼最小長度
minlen = 12

# 至少包含一個數字
dcredit = -1

# 至少包含一個大寫字母
ucredit = -1

# 至少包含一個小寫字母
lcredit = -1

# 至少包含一個特殊字符
ocredit = -1
EOF
```

#### A.6.2 強化 Fail2Ban 設定

```bash
# 針對密碼認證加強 Fail2Ban 設定
sudo tee /etc/fail2ban/jail.local << 'EOF'
[sshd]
enabled = true
port = ssh
filter = sshd
logpath = /var/log/auth.log
maxretry = 3        # 降低重試次數
bantime = 1800      # 增加封鎖時間
findtime = 300      # 檢測時間窗口
EOF

sudo systemctl restart fail2ban
```

#### A.6.3 定期密碼更新

```bash
# 建立定期密碼更新腳本
sudo tee /usr/local/bin/rotate-passwords.sh << 'EOF'
#!/bin/bash

LOG_FILE="/var/log/password-rotation.log"
echo "$(date): Starting password rotation" >> $LOG_FILE

# 為所有用戶生成新密碼
for user in $(ls /home | grep "^user[0-9]"); do
    NEW_PASSWORD=$(openssl rand -base64 16)
    echo "$user:$NEW_PASSWORD" | sudo chpasswd
    echo "$user:$NEW_PASSWORD" >> /tmp/rotated_passwords_$(date +%Y%m%d).txt
    echo "$(date): Password rotated for $user" >> $LOG_FILE
done

# 設定文件權限
chmod 600 /tmp/rotated_passwords_*.txt

echo "$(date): Password rotation completed" >> $LOG_FILE
EOF

sudo chmod +x /usr/local/bin/rotate-passwords.sh

# 設定每月自動輪換（可選）
echo "0 2 1 * * /usr/local/bin/rotate-passwords.sh" | sudo crontab -
```

### A.7 優缺點比較

#### 密碼認證的優點
- **設定簡單**：不需要管理 SSH 金鑰
- **用戶友善**：用戶只需記住密碼
- **快速部署**：批量建立用戶更容易
- **靈活管理**：可以隨時更改密碼

#### 密碼認證的缺點
- **安全性較低**：容易受到暴力破解攻擊
- **密碼管理**：需要安全地分發和管理密碼
- **網路風險**：密碼可能在網路傳輸中被截獲
- **合規問題**：某些企業政策可能不允許密碼認證

#### 建議的混合方案

```bash
# 同時啟用金鑰和密碼認證
PasswordAuthentication yes
PubkeyAuthentication yes

# 優先使用金鑰認證
AuthenticationMethods publickey,password
```

這樣用戶可以選擇使用金鑰或密碼，提供更大的靈活性。

### A.8 總結

將 SSH 金鑰認證改為密碼認證主要涉及：

1. **SSH 服務器設定**：啟用 `PasswordAuthentication`
2. **用戶管理**：為用戶設定密碼而非 SSH 金鑰
3. **本機 SSH 設定**：移除 `IdentityFile`，添加 `PreferredAuthentications password`
4. **VS Code 設定**：確保支援密碼輸入
5. **安全加固**：強化密碼政策和 Fail2Ban 設定

雖然密碼認證在管理上更簡單，但建議在生產環境中仍使用 SSH 金鑰認證以確保更高的安全性。
