スマホからも PC からも使えるプライベート LLM 環境 (Qwen 3.5-4B) を AWS に構築してみた

# --- AMI ---

data "aws_ami" "deep_learning_base" {
  count       = var.ami_id == "" ? 1 : 0
  most_recent = true
  owners      = ["amazon"]

  filter {
    name   = "name"
    values = ["Deep Learning Base OSS Nvidia Driver GPU AMI (Ubuntu 22.04) *"]
  }

  filter {
    name   = "architecture"
    values = ["x86_64"]
  }
}

locals {
  ami_id = var.ami_id != "" ? var.ami_id : data.aws_ami.deep_learning_base[0].id
}

# --- Network ---

data "aws_vpc" "default" {
  default = true
}

data "aws_subnets" "default" {
  filter {
    name   = "vpc-id"
    values = [data.aws_vpc.default.id]
  }

  filter {
    name   = "default-for-az"
    values = ["true"]
  }
}

resource "aws_security_group" "llm" {
  name_prefix = "qwen-llm-"
  description = "Qwen LLM - inbound denied, outbound allowed"
  vpc_id      = data.aws_vpc.default.id

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
    description = "Allow all outbound traffic"
  }

  tags = {
    Name = "qwen-llm"
  }

  lifecycle {
    create_before_destroy = true
  }
}

# --- IAM Role (for self-stop via AWS API) ---

resource "aws_iam_role" "llm" {
  name = "qwen-llm-ec2"

  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Action = "sts:AssumeRole"
      Effect = "Allow"
      Principal = {
        Service = "ec2.amazonaws.com"
      }
    }]
  })

  tags = {
    Name = "qwen-llm"
  }
}

resource "aws_iam_role_policy" "llm_self_stop" {
  name = "self-stop"
  role = aws_iam_role.llm.id

  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Effect   = "Allow"
      Action   = "ec2:StopInstances"
      Resource = "*"
      Condition = {
        StringEquals = {
          "ec2:ResourceTag/Name" = "qwen-llm"
        }
      }
    }]
  })
}

resource "aws_iam_role_policy_attachment" "llm_ssm" {
  role       = aws_iam_role.llm.name
  policy_arn = "arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore"
}

resource "aws_iam_instance_profile" "llm" {
  name = "qwen-llm-ec2"
  role = aws_iam_role.llm.name
}

# --- EC2 Spot Instance ---

resource "aws_instance" "llm" {
  ami           = local.ami_id
  instance_type = var.instance_type

  instance_market_options {
    market_type = "spot"
    spot_options {
      max_price                      = var.spot_max_price
      spot_instance_type             = "persistent"
      instance_interruption_behavior = "stop"
    }
  }

  iam_instance_profile = aws_iam_instance_profile.llm.name

  vpc_security_group_ids      = [aws_security_group.llm.id]
  subnet_id                   = tolist(data.aws_subnets.default.ids)[0]
  associate_public_ip_address = true

  root_block_device {
    volume_size           = var.root_volume_size
    volume_type           = "gp3"
    delete_on_termination = true
  }

  user_data_base64 = base64encode(templatefile("${path.module}/userdata.sh", {
    tailscale_auth_key = var.tailscale_auth_key
    open_webui_port    = var.open_webui_port
  }))

  tags = {
    Name = "qwen-llm"
  }
}

#!/bin/bash
set -euxo pipefail

exec > >(tee /var/log/userdata.log) 2>&1
echo "=== User Data: started at $(date) ==="

# Skip if already initialized (for stop/start cycles)
if [ -f /opt/qwen-llm/.initialized ]; then
  echo "Already initialized. Exiting."
  exit 0
fi

# ---- Install AWS CLI (for auto-shutdown via API) ----
apt-get update
apt-get install -y ca-certificates curl gnupg unzip conntrack
if ! command -v aws &> /dev/null; then
  curl -fsSL "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "/tmp/awscliv2.zip"
  unzip -q /tmp/awscliv2.zip -d /tmp
  /tmp/aws/install
  rm -rf /tmp/aws /tmp/awscliv2.zip
fi

# ---- Install Docker (skip if pre-installed on Deep Learning AMI) ----
if ! command -v docker &> /dev/null; then
  install -m 0755 -d /etc/apt/keyrings
  curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
    | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
  chmod a+r /etc/apt/keyrings/docker.gpg

  echo \
    "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
    $(. /etc/os-release && echo "$VERSION_CODENAME") stable" \
    | tee /etc/apt/sources.list.d/docker.list > /dev/null

  apt-get update
  apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
else
  echo "Docker already installed, skipping."
fi

# ---- Install NVIDIA Container Toolkit (skip if pre-installed) ----
if ! dpkg -l nvidia-container-toolkit &> /dev/null; then
  rm -f /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
  curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey \
    | gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg

  curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list \
    | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' \
    | tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

  apt-get update
  apt-get install -y nvidia-container-toolkit
else
  echo "NVIDIA Container Toolkit already installed, skipping."
fi

# Ensure Docker is configured for NVIDIA runtime
nvidia-ctk runtime configure --runtime=docker
systemctl restart docker

# ---- Install Tailscale ----
curl -fsSL https://tailscale.com/install.sh | sh
set +x  # auth key をログに出力しない
tailscale up --auth-key=${tailscale_auth_key} --hostname=qwen-llm
set -x

# ---- Create Docker Compose file ----
mkdir -p /opt/qwen-llm
cat > /opt/qwen-llm/docker-compose.yml << 'COMPOSE_EOF'
services:
  ollama:
    image: ollama/ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    environment:
      - OLLAMA_KEEP_ALIVE=-1
      - OLLAMA_NUM_PARALLEL=4
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    restart: unless-stopped

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    ports:
      - "${open_webui_port}:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
      - ENABLE_TITLE_GENERATION=false
      - ENABLE_TAGS_GENERATION=false
      - ENABLE_SEARCH_QUERY_GENERATION=false
    volumes:
      - open_webui_data:/app/backend/data
    depends_on:
      - ollama
    restart: unless-stopped

volumes:
  ollama_data:
  open_webui_data:
COMPOSE_EOF

# ---- Start services ----
cd /opt/qwen-llm
docker compose up -d

# ---- Wait for Ollama and pull model ----
echo "Waiting for Ollama to be ready..."
for i in $(seq 1 60); do
  if curl -sf http://localhost:11434/api/tags > /dev/null 2>&1; then
    echo "Ollama is ready!"
    break
  fi
  echo "Waiting... ($i/60)"
  sleep 5
done

echo "Pulling Qwen 3.5-4B model..."
docker exec $(docker ps -qf "ancestor=ollama/ollama") ollama pull qwen3.5:4b

# ---- Auto-shutdown script ----
cat > /opt/qwen-llm/auto-shutdown.sh << 'SHUTDOWN_EOF'
#!/bin/bash
# Open WebUI への TCP 接続を conntrack で監視し、
# 一定時間アイドル状態が続いた場合にインスタンスを停止する。
# Docker NAT 越しの接続は ss では見えないため conntrack を使用する。
IDLE_THRESHOLD=3600
TIMESTAMP_FILE="/tmp/last-activity"
WEBUI_PORT=${open_webui_port}

ACTIVE_CONNECTIONS=$(conntrack -L -p tcp --dport "$WEBUI_PORT" 2>/dev/null \
  | grep -c ESTABLISHED || echo "0")

if [ "$ACTIVE_CONNECTIONS" -gt 0 ]; then
  date +%s > "$TIMESTAMP_FILE"
  exit 0
fi

if [ ! -f "$TIMESTAMP_FILE" ]; then
  date +%s > "$TIMESTAMP_FILE"
  exit 0
fi

LAST_ACTIVITY=$(cat "$TIMESTAMP_FILE")
CURRENT_TIME=$(date +%s)
IDLE_TIME=$((CURRENT_TIME - LAST_ACTIVITY))

if [ "$IDLE_TIME" -ge "$IDLE_THRESHOLD" ]; then
  INSTANCE_ID=$(curl -sf http://169.254.169.254/latest/meta-data/instance-id)
  REGION=$(curl -sf http://169.254.169.254/latest/meta-data/placement/region)
  logger "auto-shutdown: Idle for $${IDLE_TIME}s. Stopping instance $${INSTANCE_ID}."
  aws ec2 stop-instances --instance-ids "$INSTANCE_ID" --region "$REGION"
fi
SHUTDOWN_EOF

chmod +x /opt/qwen-llm/auto-shutdown.sh

# Cron job: run every 5 minutes + reboot 時にタイムスタンプを初期化
printf '%s\n%s\n' \
  '@reboot root date +\%s > /tmp/last-activity' \
  '*/5 * * * * root /opt/qwen-llm/auto-shutdown.sh >> /var/log/auto-shutdown.log 2>&1' \
  > /etc/cron.d/auto-shutdown
chmod 644 /etc/cron.d/auto-shutdown

# Initialize timestamp
date +%s > /tmp/last-activity

# Mark as initialized
touch /opt/qwen-llm/.initialized

echo "=== User Data: completed at $(date) ==="

次の for 文を高速化してください。
```c
for (i = 0; i < n; i++) {
  for (j = 0; j < n; j++) {
    a[j][i]++;
  }
}
```

----

C の 2 次元配列（または multidimensional array）を高速化するための最も効果的な最適化は、**「メモリアccess パターン（キャッシュローカリティ）」**の改善です。

そのための具体的な手順とコード例を提示します。

### 1. メモリアクセスパターンの問題点
C のマルチディメンション配列は通常、**Row-Major order**（行優先）でメモリに配置されています。つまり、同じ行にある要素同士はメモリ上も隣接して配置されています。

*   **元のコード（高速化前）:**
    ```c
    // i を外ループ，j を内ループ
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            a[j][i]++; // 行番号 j は固定されない。列 index i が変わってくる。
        }
    }
    ```
  *   **問題:** `a[j][i]` ここで外ループが `i` (column) を動かすと、内ループで `j` (row) が変更されていき、メモリ上のアクセスは**「列を下から上へ（縦）」**に行きます。これにより、連続したメモリにアクセスせず、キャッシュにミスが発生し、大量のメモリアクセスがサーバーへ送られることになります。

### 2. 高速化後のコード
**内側ループを `i` から `j` に変更する**だけで、メモリ上のアクセスは「行を横から右へ（横）」に変更されます。これにより、連続したメモリ要素へのアクセスが可能になり、キャッシュヒット率が劇的に向上します。

```c
// Optimized Code: Loop Reorder (Row-Major)
int n = /* your size */;
// Assuming a is declared as int a[n][n] or similar contiguous structure.
for (j = 0; j < n; j++) {
    for (i = 0; i < n; i++) {
        // Memory access order: a[j][0], a[j][1], ..., a[j][n-1]
        // This is ROW-MAJORITY traversal.
        a[j][i]++; 
    }
}
```

### 3. 高速化の原理：キャッシュ効率
*   **Cache Line:** 一般に CPU のキャッシュラインは 64 bytes (8 words) です。
*   **Row-Major Access:** `a[j][0]...` と並んでアクセスすることで、次の要素が即座にキャッシュから取得できます（Prefetching が効きます）。
*   **Column-Major Access:** `a[0][i], a[1][i]...` はメモリアクセスはランダムになり、データが異なるキャッシュライン上にあればその度にディスクまたは RAM の直接メモリにアクセスする必要が発生します。

### 4. その他の高度な最適化オプション
上記のループ順の変更に加え、以下のオプションを組み合わせるとさらに高速化が期待できます。

#### A. コンパイラフラグ
コンパイラが自動で最適化を行う必要があります。
*   `-O3`: 高度なコード生成（例：関数アンラーリング、内側ループの展開など）。
*   `-march=native`: プロセサー固有の指令セットを使用します（AVX2, AVX-512, SSE などによるベクトル演算が可能に）。

#### B. SIMD / 並列化 (OpenMP)
CPU のコアを同時に活用できますが、`++` 演算子には**「Atomic Operation」**が必要になります。

```c
#pragma omp parallel for reduction(+:sum_variable) if (n > 100) // reduction は不要の場合の省略形は避けるので明示的
for (j = 0; j < n; j++) {
    #pragma omp simd // ベクトル化を指示（CPU が対応していれば有効）
    for (i = 0; i < n; i++) {
        a[j][i]++; // これらは異なるコアが書き込むため、OpenMP で並列化すると各コア内部で atomic な挙動が必要。
        // しかし，単純に a[j][i]++ とした場合、原子性は必要ないのか？
        // 注意：a[j][i]++ は値を読み込み、変更し、書き戻す動作。
        // もし複数のスレッドが同じ a[j][i] にアクセスする必要があるなら atomic な処理が必要。
    }
}
```
※通常、OpenMP で並列化する場合の `reduction` を使用しないと結果が崩れる可能性があります（原子性確保のため）。
しかし、上記コードの場合は「すべてを増す」だけなので、`sum` 計算などは不要です。もし単純に配列全体を増やせば、**ループ分割されたスレッド間でデータ独立性**がある場合は並列化できます。

### まとめ：最優先すべき変更
1. **ループ順序の切り替え**: `for(i...) for(j...)` → `for(j...) for(i...)`。これが最も直接的かつ効果的な最適化です。
2. **コンパイラオプションの適用**: `-O3 -march=native` を使用してください。
3. **メモリアライメント（追加）**: `a[j][i]` にアクセスする場合、`a[j]` はポインタとして扱えますが、動的配列の場合、`int *ptr = &a[j];` として明示的にポインタ演算を行うことでキャッシュヒット率がさらに向上する可能性があります。ただし、静的な `int a[n][n]` の場合も同様です。

最終的なコードは以下のようになります（ループ順の切り替えのみ）。

```c
// Final Optimized Code
for (j = 0; j < n; j++) { // Outer loop for Rows (Cache Locality)
    for (i = 0; i < n; i++) { // Inner loop for Columns (Sequential Access)
        a[j][i]++;
    }
}
```

DevelopersIO の越井琢巳という執筆者について教えてください。

----

申し訳ありませんが、「DevelopersIO の越井琢巳」という個人について、信頼できる公的な情報源（公式プロフィール、記事、メディアなどの確立されたデータ）を検索できません。

可能性としては以下の通りです：
- **名称や組織名の誤記**：開発者向けのコミュニティや技術系の団体名が類似している場合があるため、より正確な名前（例：「DevelopersIO」ではなく「Devs.io」または別の名称など）と確認をお勧めします。
- **限られた公開情報**：個人が公開活動を行っていない、あるいは情報が非公式なブログや SNS 上でしか存在しない可能性もあります。

正確な情報を提供する際は、名前や所属組織の正しい表記（ローマ字・英字）、または具体的な役割（例：技術作家、プロジェクトリーダーなど）を補足いただけますでしょうか？さらに検索精度を高めるため、以下の点をご確認いただくお手伝いができます。