Apple Container ツール入門ガイド

## はじめに

Apple Container は、macOS専用に設計された革新的なコンテナ化ツールです。従来のDockerとは異なり、各コンテナを軽量な仮想マシン（VM）として実行することで、より強固なセキュリティと分離性を提供します。

## Apple Container とは何か

Apple Container は、Apple Silicon Mac上でLinuxコンテナを実行するためのツールです。最大の特徴は、各コンテナが独自の軽量Linux仮想マシン内で動作することです。これは、Apple独自の**containerization**システムを基盤としており、VM-per-containerアーキテクチャを採用することで、従来のコンテナ技術よりも高いセキュリティレベルを実現しています。

> **技術的背景**: Apple Containerは、Swift言語で開発されたcontainerizationシステム上に構築されています。このシステムは、Apple Silicon向けに最適化されたVirtualization.frameworkを活用し、各コンテナを軽量VMとして実行します。内部では、vminitdと呼ばれる専用のinit systemがPID 1として動作し、ホストとゲスト間の通信をgRPC over vsockで行います。

### 従来のDockerとの違い

従来のDockerなどのコンテナ技術では、複数のコンテナがホストOSのカーネルを共有します。一方、Apple Containerでは以下のような違いがあります：

| 項目 | 従来のDocker | Apple Container |
|------|-------------|-----------------|
| **実行環境** | 共有Linuxカーネル | 個別の軽量Linux VM |
| **セキュリティ** | プロセス分離 | VM レベル分離 |
| **対応OS** | Linux, Windows, macOS | macOS専用 |
| **アーキテクチャ** | 様々なプラットフォーム | Apple Silicon最適化 |
| **リソース使用** | 軽量 | 軽量VM（若干のオーバーヘッド） |

### macOS専用設計の特徴

Apple Containerは、macOSの以下のフレームワークと深く統合されています：

- **Virtualization Framework**: 軽量VMの作成と管理
- **vmnet Framework**: 仮想ネットワークの提供
- **XPC Framework**: プロセス間通信
- **launchd**: システムサービス管理

この深い統合により、macOS環境において最適なパフォーマンスとセキュリティを実現しています。

## システム要件

Apple Containerを使用するには、以下の要件を満たす必要があります：

### ハードウェア要件
- **Apple Silicon Mac**: M1、M2、M3、またはそれ以降のチップ
- **メモリ**: 十分なRAM（軽量VMを実行するため）

### ソフトウェア要件
- **macOS 26 Beta 1以降**: 推奨バージョン（全機能サポート）
- **macOS 15**: サポート対象だが、ネットワーク機能に制限あり
- **管理者権限**: インストールとDNS設定に必要

### 重要な注意事項

macOS 15では以下の制限があります：
- コンテナ間通信が制限される
- ネットワーク設定でタイミング問題が発生する可能性
- 手動でのサブネット設定が必要な場合がある

最適な体験のためには、macOS 26 Beta 1以降の使用を強く推奨します。

## Apple Containerの利点

### 1. 強化されたセキュリティ
各コンテナが独立したVMで実行されるため、コンテナ間の分離性が向上し、セキュリティリスクが軽減されます。

### 2. macOSとの深い統合
macOSのネイティブフレームワークを活用することで、システムとの親和性が高く、安定した動作を実現します。

### 3. OCI準拠
Open Container Initiative（OCI）標準に完全準拠しているため、既存のDockerイメージをそのまま使用できます。

### 4. 開発効率の向上
macOS開発者にとって自然な操作感で、コンテナ化されたアプリケーションの開発とテストが可能です。

# インストールと初期設定

## 概要

このチャプターでは、Apple Containerのインストール手順から初期設定まで、実際にシステムを使い始めるために必要なすべての手順を詳しく説明します。初心者の方でも迷わずに進められるよう、各ステップを丁寧に解説していきます。

## インストール前の準備

### システム要件の確認

まず、お使いのMacがApple Containerの要件を満たしているか確認しましょう。

> **技術的背景**: Apple Containerは、macOSのVirtualization.frameworkに依存しており、各コンテナが軽量VMとして実行されます。このため、Apple Silicon Macと十分なシステムリソースが必要です。また、containerizationシステムは、vmnetフレームワークを使用して仮想ネットワーク（192.168.64.0/24サブネット）を構築します。

#### ハードウェアの確認
ターミナルを開いて、以下のコマンドでチップの種類を確認します：

```bash
uname -m
```

出力が `arm64` であれば、Apple Silicon Mac（M1、M2、M3など）です。`x86_64` の場合は、Intel Macのため、Apple Containerは使用できません。

#### macOSバージョンの確認
システム情報でmacOSのバージョンを確認します：

```bash
sw_vers
```

出力例：
```
ProductName:		macOS
ProductVersion:		15.0
BuildVersion:		24A335
```

macOS 15以降であれば基本的な動作は可能ですが、macOS 26 Beta 1以降が推奨されます。

### 管理者権限の確認

Apple Containerのインストールには管理者権限が必要です。以下のコマンドで確認できます：

```bash
sudo -v
```

パスワードの入力を求められ、エラーが出なければ管理者権限があります。

## インストール手順

### 1. インストーラーのダウンロード

Apple Containerの公式GitHubリリースページから、最新の署名済みインストーラーパッケージをダウンロードします。

1. ブラウザで GitHub の Apple Container リリースページにアクセス
2. 最新リリースの `.pkg` ファイルをダウンロード
3. ダウンロードフォルダに保存されることを確認

### 2. インストーラーの実行

ダウンロードした `.pkg` ファイルをダブルクリックして、インストールウィザードを開始します。

インストール過程で以下の処理が行われます：
- `/usr/local/bin/` にCLIバイナリがインストール
- `/usr/local/libexec/` にヘルパーサービスがインストール
- Launch Agentの登録
- 必要なディレクトリ構造の作成

管理者パスワードの入力を求められたら、入力してインストールを完了させます。

### 3. インストールの確認

インストールが正常に完了したか確認しましょう：

```bash
container --version
```

正常にインストールされていれば、バージョン情報が表示されます：

```
container version 0.1.0
```

もしコマンドが見つからない場合は、新しいターミナルセッションを開いてから再度試してください。

## 初期設定

### システムサービスの開始

Apple Containerを使用する前に、必要なシステムサービスを開始する必要があります。

```bash
container system start
```

初回実行時は、以下のような出力が表示される場合があります：

```
% container system start

Verifying apiserver is running...
Installing base container filesystem...
No default kernel configured.
Install the recommended default kernel from [https://github.com/kata-containers/kata-containers/releases/download/3.17.0/kata-static-3.17.0-arm64.tar.xz]? [Y/n]: 
```

### カーネルのインストール

Apple Containerは、コンテナを実行するためにLinuxカーネルが必要です。初回起動時に推奨カーネルのインストールを求められます。

#### 推奨カーネルのインストール
プロンプトが表示されたら、`Y` または `Enter` キーを押して推奨カーネルをインストールします：

```
Install the recommended default kernel from [https://github.com/kata-containers/kata-containers/releases/download/3.17.0/kata-static-3.17.0-arm64.tar.xz]? [Y/n]: y
Installing kernel...
```

カーネルのダウンロードとインストールには数分かかる場合があります。インターネット接続が必要です。

#### カーネルインストールの確認
インストールが完了すると、以下のコマンドでカーネルの状態を確認できます：

```bash
container system kernel list
```

### サービス状態の確認

システムサービスが正常に起動しているか確認しましょう：

```bash
container system status
```

正常に起動していれば、以下のような情報が表示されます：
- API サーバーの状態
- 利用可能なプラグインサービス
- ネットワーク設定の状態

### 初回動作確認

すべてが正常に設定されているか、簡単なテストを実行してみましょう：

```bash
container list --all
```

初期状態では何もコンテナが実行されていないため、以下のような空の一覧が表示されます：

```
ID  IMAGE  OS  ARCH  STATE  ADDR
```

この出力が表示されれば、Apple Containerが正常にインストールされ、動作可能な状態になっています。

## オプション設定

### DNS設定（推奨）

コンテナにホスト名でアクセスできるよう、DNS設定を行うことを推奨します。この設定により、IPアドレスの代わりに `container-name.test` のような形式でコンテナにアクセスできるようになります。

#### DNS ドメインの作成
```bash
sudo container system dns create test
```

このコマンドは管理者権限が必要です。パスワードの入力を求められます。

#### デフォルトDNSドメインの設定
```bash
container system dns default set test
```

#### DNS設定の確認
設定が正常に適用されているか確認します：

```bash
container system dns list
```

### ネットワーク設定の確認

Apple Containerは、デフォルトで `192.168.64.0/24` サブネットを使用します。ネットワーク設定を確認してみましょう：

```bash
ifconfig | grep bridge
```

`bridge100` インターフェースが表示されれば、仮想ネットワークが正常に設定されています。

## アップグレード手順

既存のApple Containerインストールをアップグレードする場合は、以下の手順を実行します：

### 1. 既存インストールの停止
```bash
container system stop
```

### 2. データ保持でのアンインストール
```bash
uninstall-container.sh -k
```

`-k` フラグにより、ユーザーデータ（コンテナイメージや設定）が保持されます。

### 3. 新バージョンのインストール
新しいインストーラーパッケージをダウンロードして、通常のインストール手順を実行します。

## トラブルシューティング

### よくある問題と解決方法

#### コマンドが見つからない
```
command not found: container
```

**解決方法**: 
1. 新しいターミナルセッションを開く
2. `/usr/local/bin` がPATHに含まれているか確認：
   ```bash
   echo $PATH | grep /usr/local/bin
   ```

#### サービス起動エラー
```
Error: Failed to start container services
```

**解決方法**:
1. 既存のプロセスを確認：
   ```bash
   ps aux | grep container
   ```
2. 必要に応じてプロセスを終了してから再起動

#### ネットワーク問題（macOS 15）
macOS 15では、ネットワーク設定で問題が発生する場合があります。

**解決方法**:
```bash
container system stop
defaults write com.apple.container.defaults network.subnet 192.168.66.1/24
container system start
```

### ログの確認

問題が発生した場合は、システムログを確認して詳細な情報を取得できます：

```bash
container system logs
```

---

# 基本的なコマンド構成の理解

## 概要

このチャプターでは、Apple Containerの基本的なコマンド構成について学習します。コマンドの階層構造を理解することで、効率的にツールを使用できるようになります。また、ヘルプシステムの活用方法についても詳しく説明します。

## コマンド階層構造

Apple Container CLIは、機能別に整理された階層構造を持っています。メインコマンド `container` の下に、3つの主要カテゴリが存在します。

### 全体構造の概要

```
container
├── コンテナ操作コマンド
│   ├── create      # コンテナの作成
│   ├── run         # コンテナの作成と実行
│   ├── start       # 停止中コンテナの開始
│   ├── stop        # 実行中コンテナの停止
│   ├── delete/rm   # コンテナの削除
│   ├── list/ls     # コンテナ一覧表示
│   ├── exec        # コンテナ内でのコマンド実行
│   ├── logs        # コンテナログの表示
│   ├── kill        # コンテナの強制終了
│   └── inspect     # コンテナ詳細情報の表示
├── イメージ操作コマンド
│   ├── build       # イメージのビルド
│   ├── images      # イメージ管理
│   │   ├── list    # イメージ一覧表示
│   │   ├── pull    # イメージの取得
│   │   ├── push    # イメージの送信
│   │   ├── tag     # イメージのタグ付け
│   │   ├── save    # イメージのエクスポート
│   │   ├── load    # イメージのインポート
│   │   ├── inspect # イメージ詳細情報
│   │   └── rm      # イメージの削除
│   └── registry    # レジストリ操作
│       ├── login   # レジストリへのログイン
│       ├── default # デフォルトレジストリ設定
│       └── ...
└── システム操作コマンド
    ├── system      # システム管理
    │   ├── start   # サービス開始
    │   ├── stop    # サービス停止
    │   ├── restart # サービス再起動
    │   ├── status  # サービス状態確認
    │   ├── logs    # システムログ表示
    │   ├── dns     # DNS設定
    │   └── kernel  # カーネル管理
    └── builder     # ビルダー管理
        ├── start   # ビルダー開始
        ├── stop    # ビルダー停止
        ├── delete  # ビルダー削除
        └── status  # ビルダー状態確認
```

## 1. コンテナ操作コマンド

コンテナのライフサイクル管理に関するコマンド群です。これらのコマンドを使って、コンテナの作成から削除まで、すべての操作を行います。

### 基本的なライフサイクル

コンテナの典型的なライフサイクルは以下の通りです：

1. **作成**: `container create` または `container run`
2. **開始**: `container start`（`run`の場合は自動実行）
3. **操作**: `container exec` でコンテナ内作業
4. **監視**: `container logs` でログ確認
5. **停止**: `container stop`
6. **削除**: `container delete`

### 主要コマンドの説明

| コマンド | 短縮形 | 用途 | 主要オプション |
|----------|--------|------|----------------|
| `create` | - | コンテナ作成（実行はしない） | `--name`, `--memory`, `--cpus` |
| `run` | - | コンテナ作成と実行 | `--detach`, `--rm`, `--interactive`, `--tty` |
| `start` | - | 停止中コンテナの開始 | - |
| `stop` | - | 実行中コンテナの停止 | `--timeout` |
| `delete` | `rm` | コンテナの削除 | `--force` |
| `list` | `ls` | コンテナ一覧表示 | `--all`, `--format` |
| `exec` | - | コンテナ内コマンド実行 | `--interactive`, `--tty` |
| `logs` | - | コンテナログ表示 | `--boot`, `--follow` |
| `kill` | - | コンテナ強制終了 | `--signal` |
| `inspect` | - | コンテナ詳細情報表示 | - |

### 実用的なコマンド例

#### コンテナの作成と実行
```bash
# バックグラウンドで実行（デタッチモード）
container run --name web-server --detach nginx

# 対話的に実行
container run --interactive --tty ubuntu bash

# リソース制限付きで実行
container run --memory 2g --cpus 4 my-app
```

#### コンテナの管理
```bash
# 全コンテナの一覧表示
container list --all

# 実行中コンテナのみ表示
container list

# JSON形式で詳細情報を表示
container list --format json
```

## 2. イメージ操作コマンド

コンテナイメージの管理とビルドに関するコマンド群です。

### イメージ管理の基本フロー

1. **取得**: `container images pull` でレジストリからダウンロード
2. **ビルド**: `container build` でDockerfileから作成
3. **管理**: `container images list` で一覧確認
4. **配布**: `container images push` でレジストリにアップロード

### buildコマンド

イメージのビルドは `container build` コマンドで行います：

```bash
# 基本的なビルド
container build --tag my-app --file Dockerfile .

# マルチアーキテクチャビルド
container build --arch arm64 --arch amd64 --tag my-app .

# ビルド引数を指定
container build --build-arg VERSION=1.0 --tag my-app .
```

### imagesサブコマンド

`container images` の下には、イメージ管理のためのサブコマンドが配置されています：

```bash
# イメージ一覧表示
container images list

# イメージの取得
container images pull python:alpine

# イメージのタグ付け
container images tag python:alpine my-python:latest

# イメージの削除
container images rm my-python:latest

# イメージの詳細情報
container images inspect python:alpine
```

### registryサブコマンド

レジストリとの連携機能：

```bash
# レジストリにログイン
container registry login ghcr.io

# デフォルトレジストリの設定
container registry default set ghcr.io

# デフォルトレジストリの確認
container registry default get
```

## 3. システム操作コマンド

Apple Container システム全体の管理に関するコマンド群です。

### systemサブコマンド

システム全体の制御を行います：

```bash
# システムサービスの開始
container system start

# システムサービスの停止
container system stop

# システムサービスの再起動
container system restart

# システム状態の確認
container system status

# システムログの表示
container system logs
```

### DNS管理

システムレベルのDNS設定：

```bash
# DNSドメインの作成
sudo container system dns create test

# デフォルトDNSドメインの設定
container system dns default set test

# DNS設定の一覧表示
container system dns list
```

### カーネル管理

Linuxカーネルの管理：

```bash
# カーネル一覧の表示
container system kernel list

# 推奨カーネルのインストール
container system kernel set --recommended

# カスタムカーネルの設定
container system kernel set --binary /path/to/kernel
```

### builderサブコマンド

イメージビルド用のビルダーコンテナ管理：

```bash
# ビルダーの開始（リソース指定）
container builder start --cpus 8 --memory 16g

# ビルダーの状態確認
container builder status

# ビルダーの停止
container builder stop

# ビルダーの削除
container builder delete
```

## ヘルプシステムの活用

Apple Container CLIには充実したヘルプシステムが組み込まれています。

### 基本的なヘルプの表示

```bash
# メインヘルプの表示
container --help

# 特定コマンドのヘルプ
container run --help

# サブコマンドのヘルプ
container images --help
container images pull --help
```

### ヘルプの階層構造

ヘルプシステムも、コマンド構造に対応した階層になっています：

```bash
# レベル1: メインコマンド
container --help

# レベル2: カテゴリコマンド
container images --help
container system --help

# レベル3: 具体的なサブコマンド
container images pull --help
container system dns --help
```

### 実用的なヘルプの使い方

#### 利用可能なオプションの確認
```bash
# runコマンドの全オプションを確認
container run --help
```

#### サブコマンドの一覧確認
```bash
# imagesカテゴリの全サブコマンドを確認
container images --help
```

#### 具体的な使用例の確認
多くのヘルプには、実際の使用例が含まれています：

```bash
container build --help
```

## コマンド短縮形とエイリアス

効率的な操作のために、多くのコマンドには短縮形が用意されています。

### 主要な短縮形

| 完全形 | 短縮形 | 用途 |
|--------|--------|------|
| `list` | `ls` | 一覧表示 |
| `delete` | `rm` | 削除 |
| `images` | `i` | イメージ操作 |
| `registry` | `r` | レジストリ操作 |
| `system` | `s` | システム操作 |

### オプションの短縮形

| 完全形 | 短縮形 | 用途 |
|--------|--------|------|
| `--all` | `-a` | 全て表示 |
| `--detach` | `-d` | バックグラウンド実行 |
| `--interactive` | `-i` | 対話モード |
| `--tty` | `-t` | 疑似端末 |
| `--file` | `-f` | ファイル指定 |
| `--memory` | `-m` | メモリ制限 |
| `--volume` | `-v` | ボリュームマウント |

### 実用例

短縮形を使った効率的なコマンド例：

```bash
# 長い形式
container list --all
container images list
container run --detach --interactive --tty ubuntu

# 短縮形
container ls -a
container i ls
container run -dit ubuntu
```

## グローバルオプション

すべてのコマンドで使用できるグローバルオプションがあります。

### 主要なグローバルオプション

| オプション | 環境変数 | 用途 |
|------------|----------|------|
| `--debug` | `CONTAINER_DEBUG` | デバッグ出力の有効化 |
| `--version` | - | バージョン情報の表示 |
| `--help` | - | ヘルプの表示 |

### デバッグモードの活用

問題が発生した場合は、デバッグモードを有効にして詳細な情報を取得できます：

```bash
# コマンド実行時にデバッグを有効化
container --debug run ubuntu

# 環境変数でデバッグを有効化
export CONTAINER_DEBUG=1
container run ubuntu
```

---

# ハンズオンチュートリアル - Pythonウェブサーバーで学ぶContainer入門

## 概要

このチャプターでは、実際にPythonウェブサーバーを構築しながら、Apple Containerの基本的な使い方を学習します。システムの起動からイメージのビルド、コンテナの実行、ネットワーク機能の確認まで、実践的な手順を通じてApple Containerの機能を体験していきます。

## チュートリアルの目標

このチュートリアルを完了すると、以下のことができるようになります：

1. Apple Containerシステムの起動と初期設定
2. Dockerfileの作成とイメージのビルド
3. コンテナの実行と管理
4. コンテナ内でのコマンド実行
5. ネットワーク機能とコンテナ間通信の確認
6. レジストリ操作（オプション）
7. システムのクリーンアップ

## 前提条件

- Chapter 1でApple Containerが正常にインストールされていること
- ターミナルの基本的な操作ができること
- テキストエディタが使用できること

## ステップ1: システムの起動

まず、Apple Containerのシステムサービスを起動します。

> **技術的背景**: `container system start` コマンドは、containerizationシステムの各コンポーネントを初期化します。これには、VirtualMachineManagerの起動、vmnetフレームワークによる仮想ネットワーク（bridge100）の作成、そしてコンテナ実行に必要なLinuxカーネルの準備が含まれます。

### システムサービスの開始

ターミナルを開いて、以下のコマンドを実行します：

```bash
container system start
```

初回実行時は、以下のような出力が表示されます：

```
% container system start

Verifying apiserver is running...
Installing base container filesystem...
No default kernel configured.
Install the recommended default kernel from [https://github.com/kata-containers/kata-containers/releases/download/3.17.0/kata-static-3.17.0-arm64.tar.xz]? [Y/n]: 
```

### カーネルのインストール

推奨カーネルのインストールを求められた場合は、`Y` または `Enter` キーを押してインストールを開始します：

```
Install the recommended default kernel from [https://github.com/kata-containers/kata-containers/releases/download/3.17.0/kata-static-3.17.0-arm64.tar.xz]? [Y/n]: y
Installing kernel...
```

カーネルのダウンロードとインストールには数分かかる場合があります。完了まで待ちましょう。

### 動作確認

システムが正常に起動したか確認します：

```bash
container list --all
```

初期状態では何もコンテナが実行されていないため、以下のような空の一覧が表示されます：

```
% container list --all
ID  IMAGE  OS  ARCH  STATE  ADDR
%
```

この出力が表示されれば、システムが正常に動作しています。

## ステップ2: プロジェクトの準備

Pythonウェブサーバーのプロジェクトを作成します。

### 作業ディレクトリの作成

```bash
mkdir web-test
cd web-test
```

### Dockerfileの作成

テキストエディタを使用して、`Dockerfile` という名前のファイルを作成し、以下の内容を記述します：

```dockerfile
FROM docker.io/python:alpine
WORKDIR /content
RUN apk add curl
RUN echo '<!DOCTYPE html><html><head><title>Hello</title></head><body><h1>Hello, world!</h1></body></html>' > index.html
CMD ["python3", "-m", "http.server", "80", "--bind", "0.0.0.0"]
```

### Dockerfileの内容説明

各行の意味を理解しておきましょう：

- `FROM docker.io/python:alpine`: Python 3がインストールされたAlpine Linuxベースイメージを使用
- `WORKDIR /content`: コンテナ内の作業ディレクトリを `/content` に設定
- `RUN apk add curl`: `curl` コマンドをインストール（後でテストに使用）
- `RUN echo ...`: 簡単なHTMLファイルを作成
- `CMD [...]`: コンテナ起動時にPythonのHTTPサーバーを起動（ポート80で待機）

## ステップ3: イメージのビルド

作成したDockerfileからコンテナイメージをビルドします。

### ビルドの実行

```bash
container build --tag web-test --file Dockerfile .
```

ビルドプロセスが開始され、以下のような出力が表示されます：

```
% container build --tag web-test --file Dockerfile .
[+] Building 45.2s (8/8) FINISHED
 => [internal] load build definition from Dockerfile
 => => transferring dockerfile: 234B
 => [internal] load .dockerignore
 => => transferring context: 2B
 => [internal] load metadata for docker.io/library/python:alpine
 => [1/4] FROM docker.io/library/python:alpine
 => [2/4] WORKDIR /content
 => [3/4] RUN apk add curl
 => [4/4] RUN echo '<!DOCTYPE html>...' > index.html
 => exporting to image
 => => exporting layers
 => => writing image sha256:25b99501f174...
 => => naming to web-test:latest
```

### ビルド結果の確認

ビルドが完了したら、イメージが正常に作成されたか確認します：

```bash
container images list
```

以下のような出力が表示されるはずです：

```
% container images list
NAME      TAG     DIGEST
python    alpine  b4d299311845147e7e47c970...
web-test  latest  25b99501f174803e21c58f9c...
%
```

`web-test` イメージとベースイメージの `python:alpine` が表示されていれば成功です。

## ステップ4: コンテナの実行

ビルドしたイメージからコンテナを実行します。

### ウェブサーバーの起動

```bash
container run --name my-web-server --detach --rm web-test
```

このコマンドの各オプションの意味：
- `--name my-web-server`: コンテナに `my-web-server` という名前を付ける
- `--detach`: バックグラウンドで実行（デタッチモード）
- `--rm`: コンテナ停止時に自動的に削除

> **技術的背景**: `container run` コマンドは、内部的に軽量VMを作成し、その中でvminitdをPID 1として起動します。vminitdは、ホストからのgRPC over vsock通信を受け取り、指定されたコンテナプロセスを実行します。各コンテナは独立したLinux VM内で動作するため、従来のDockerよりも強固な分離性を提供します。

### 実行中コンテナの確認

```bash
container ls
```

以下のような出力が表示されます：

```
% container ls
ID             IMAGE                                               OS     ARCH   STATE    ADDR
buildkit       ghcr.io/apple/container-builder-shim/builder:0.0.3  linux  arm64  running  192.168.64.2
my-web-server  web-test:latest                                     linux  arm64  running  192.168.64.3
%
```

`my-web-server` コンテナが `running` 状態で、IPアドレス（この例では `192.168.64.3`）が割り当てられていることを確認できます。

## ステップ5: ウェブサーバーへのアクセス

実行中のウェブサーバーにアクセスしてみましょう。

### ブラウザでのアクセス

コンテナのIPアドレスを使用してブラウザでアクセスします：

```bash
open http://192.168.64.3
```

**注意**: IPアドレスは環境によって異なります。`container ls` コマンドで確認したIPアドレスを使用してください。

ブラウザが開き、「Hello, world!」と表示されれば成功です。

### DNS設定（オプション）

Chapter 1でDNS設定を行った場合は、ホスト名でもアクセスできます：

```bash
open http://my-web-server.test
```

## ステップ6: コンテナ内でのコマンド実行

実行中のコンテナ内でコマンドを実行してみましょう。

### 非対話的なコマンド実行

```bash
container exec my-web-server ls /content
```

出力例：
```
% container exec my-web-server ls /content
index.html
%
```

### 対話的なシェルセッション

```bash
container exec --tty --interactive my-web-server sh
```

対話的なシェルが開始されます：

```
% container exec --tty --interactive my-web-server sh
/content # ls
index.html
/content # uname -a
Linux my-web-server 6.12.28 #1 SMP Tue May 20 15:19:05 UTC 2025 aarch64 Linux
/content # cat index.html
<!DOCTYPE html><html><head><title>Hello</title></head><body><h1>Hello, world!</h1></body></html>
/content # exit
%
```

シェル内では以下のことを試してみてください：
- `ls`: ファイル一覧の確認
- `uname -a`: システム情報の表示
- `cat index.html`: HTMLファイルの内容確認
- `exit`: シェルの終了

## ステップ7: ログの確認

コンテナのログを確認する方法を学習しましょう。

### アプリケーションログの表示

```bash
container logs my-web-server
```

Pythonウェブサーバーのアクセスログが表示されます：

```
% container logs my-web-server
Serving HTTP on 0.0.0.0 port 80 (http://0.0.0.0:80/) ...
192.168.64.1 - - [10/Jun/2025 02:15:23] "GET / HTTP/1.1" 200 -
```

### ブートログの表示

コンテナ（VM）の起動ログも確認できます：

```bash
container logs --boot my-web-server
```

## ステップ8: コンテナ間通信のテスト

別のコンテナから、実行中のウェブサーバーにアクセスしてみましょう。

### 一時的なコンテナでのテスト

```bash
container run -it --rm web-test curl http://192.168.64.3
```

**注意**: IPアドレスは実際の `my-web-server` のアドレスに置き換えてください。

成功すると、HTMLコンテンツが表示されます：

```
% container run -it --rm web-test curl http://192.168.64.3
<!DOCTYPE html><html><head><title>Hello</title></head><body><h1>Hello, world!</h1></body></html>
%
```

### DNS名を使用したアクセス（DNS設定済みの場合）

```bash
container run -it --rm web-test curl http://my-web-server.test
```

このテストにより、コンテナ間のネットワーク通信が正常に動作していることを確認できます。

## ステップ9: レジストリ操作（発展編）

作成したイメージをコンテナレジストリにプッシュする方法を学習します。これはオプションのステップです。

### レジストリへのログイン

```bash
container registry login registry.example.com
```

**注意**: 実際のレジストリURLに置き換えてください（例：`ghcr.io`, `docker.io`など）。

### イメージのタグ付け

```bash
container images tag web-test registry.example.com/your-username/web-test:latest
```

### イメージのプッシュ

```bash
container images push registry.example.com/your-username/web-test:latest
```

### リモートイメージからの実行テスト

ローカルイメージを削除して、リモートから実行してみます：

```bash
# 現在のコンテナを停止
container stop my-web-server

# ローカルイメージを削除
container images delete web-test registry.example.com/your-username/web-test:latest

# リモートイメージから実行
container run --name my-web-server --detach --rm registry.example.com/your-username/web-test:latest
```

## ステップ10: クリーンアップ

チュートリアルの最後に、作成したリソースをクリーンアップします。

### コンテナの停止

```bash
container stop my-web-server
```

`--rm` オプションを使用したため、コンテナは自動的に削除されます。

### コンテナ削除の確認

```bash
container list --all
```

`my-web-server` が一覧から消えていることを確認します：

```
% container list --all
ID        IMAGE                                               OS     ARCH   STATE    ADDR
buildkit  ghcr.io/apple/container-builder-shim/builder:0.0.3  linux  arm64  running  192.168.64.2
%
```

### システムサービスの停止

```bash
container system stop
```

これにより、すべてのApple Containerサービスが停止します。

## トラブルシューティング

チュートリアル中に問題が発生した場合の対処法を説明します。

### よくある問題

#### 1. ビルドエラー
```
Error: failed to build image
```

**解決方法**:
- Dockerfileの構文を確認
- インターネット接続を確認
- `container system logs` でエラー詳細を確認

#### 2. コンテナが起動しない
```
Error: failed to start container
```

**解決方法**:
- `container logs container-name` でログを確認
- リソース不足の可能性を確認
- システムを再起動して再試行

#### 3. ネットワークアクセスできない
```
curl: (7) Failed to connect to 192.168.64.3 port 80
```

**解決方法**:
- `container ls` でIPアドレスを再確認
- ファイアウォール設定を確認
- macOS 15の場合は、ネットワーク制限の可能性

### デバッグ方法

詳細な情報が必要な場合は、デバッグモードを有効にします：

```bash
container --debug run web-test
```

または環境変数で設定：

```bash
export CONTAINER_DEBUG=1
container run web-test
```

---

# コマンドリファレンス

## 概要

このチャプターでは、Apple Containerの各コマンドについて詳細に解説します。Chapter 3のチュートリアルで基本的な使い方を学習した後、ここではより高度なオプションや実用的な使用例を含めて、各コマンドを体系的に説明していきます。

## コマンドリファレンスの構成

このチャプターは以下の3つのセクションに分かれています：

1. **コンテナ操作コマンド**: コンテナのライフサイクル管理
2. **イメージ管理コマンド**: イメージのビルド、配布、管理
3. **システム管理コマンド**: システム全体の設定と管理

各コマンドについて、以下の情報を提供します：
- 基本的な構文と用途
- 主要なオプションと説明
- 実用的な使用例
- 関連するコマンドとの組み合わせ

## 1. コンテナ操作コマンド

### container run

コンテナの作成と実行を同時に行う、最も頻繁に使用されるコマンドです。

#### 基本構文
```bash
container run [OPTIONS] IMAGE [COMMAND] [ARG...]
```

#### 主要オプション

| オプション | 短縮形 | 説明 | デフォルト |
|------------|--------|------|------------|
| `--name` | - | コンテナ名を指定 | 自動生成 |
| `--detach` | `-d` | バックグラウンドで実行 | フォアグラウンド |
| `--interactive` | `-i` | STDINを開いたままにする | false |
| `--tty` | `-t` | 疑似TTYを割り当て | false |
| `--rm` | - | 終了時にコンテナを自動削除 | false |
| `--memory` | `-m` | メモリ制限を設定 | 1GB |
| `--cpus` | - | CPU制限を設定 | 4 |
| `--volume` | `-v` | ボリュームをマウント | - |
| `--mount` | - | 詳細なマウント設定 | - |
| `--dns-domain` | - | DNS ドメインを設定 | test |

#### 実用例

**基本的な実行**
```bash
# シンプルな実行
container run ubuntu echo "Hello World"

# 対話的なシェル
container run -it ubuntu bash

# バックグラウンドで実行
container run -d --name web-server nginx
```

**リソース制限**
```bash
# メモリとCPUを制限
container run --memory 2g --cpus 2 my-app

# 大きなリソースを割り当て
container run --memory 16g --cpus 8 heavy-workload
```

**ボリュームマウント**
```bash
# ホストディレクトリをマウント
container run -v ${HOME}/data:/app/data my-app

# 複数のボリュームをマウント
container run \
  -v ${HOME}/config:/etc/config \
  -v ${HOME}/logs:/var/log \
  my-app
```

### container create

コンテナを作成するが実行はしないコマンドです。後で `container start` で開始できます。

#### 基本構文
```bash
container create [OPTIONS] IMAGE [COMMAND] [ARG...]
```

#### 使用例
```bash
# コンテナを作成（実行はしない）
container create --name my-container ubuntu

# 後で開始
container start my-container
```

### container start / stop

既存のコンテナの開始と停止を行います。

#### 基本構文
```bash
container start [OPTIONS] CONTAINER [CONTAINER...]
container stop [OPTIONS] CONTAINER [CONTAINER...]
```

#### 使用例
```bash
# コンテナを開始
container start my-container

# 複数のコンテナを同時に開始
container start web-server database cache

# コンテナを停止
container stop my-container

# 強制停止（タイムアウト指定）
container stop --timeout 30 my-container
```

### container list / ls

コンテナの一覧を表示します。

#### 基本構文
```bash
container list [OPTIONS]
container ls [OPTIONS]  # 短縮形
```

#### 主要オプション

| オプション | 短縮形 | 説明 |
|------------|--------|------|
| `--all` | `-a` | 停止中のコンテナも表示 |
| `--format` | - | 出力形式を指定（json） |

#### 使用例
```bash
# 実行中のコンテナのみ表示
container ls

# すべてのコンテナを表示
container ls -a

# JSON形式で出力
container ls --format json

# jqと組み合わせて特定の情報を抽出
container ls --format json | jq '.[] | {name: .configuration.id, ip: .networks[0].address}'
```

### container exec

実行中のコンテナ内でコマンドを実行します。

#### 基本構文
```bash
container exec [OPTIONS] CONTAINER COMMAND [ARG...]
```

#### 主要オプション

| オプション | 短縮形 | 説明 |
|------------|--------|------|
| `--interactive` | `-i` | STDINを開いたままにする |
| `--tty` | `-t` | 疑似TTYを割り当て |

#### 使用例
```bash
# 単発コマンドの実行
container exec my-container ls /app

# 対話的なシェルセッション
container exec -it my-container bash

# 環境変数を設定してコマンド実行
container exec my-container env VAR=value my-command

# ファイルの内容確認
container exec my-container cat /etc/hosts
```

### container logs

コンテナのログを表示します。

#### 基本構文
```bash
container logs [OPTIONS] CONTAINER
```

#### 主要オプション

| オプション | 説明 |
|------------|------|
| `--boot` | ブートログを表示 |
| `--follow` | ログをリアルタイムで追跡 |

#### 使用例
```bash
# アプリケーションログを表示
container logs my-web-server

# ブートログを表示
container logs --boot my-container

# ログをリアルタイムで監視
container logs --follow my-web-server
```

### container inspect

コンテナの詳細情報をJSON形式で表示します。

#### 基本構文
```bash
container inspect CONTAINER [CONTAINER...]
```

#### 使用例
```bash
# コンテナの詳細情報を表示
container inspect my-container

# jqで特定の情報を抽出
container inspect my-container | jq '.networks[0].address'

# 複数コンテナの情報を一度に取得
container inspect web-server database
```

### container delete / rm

コンテナを削除します。

#### 基本構文
```bash
container delete [OPTIONS] CONTAINER [CONTAINER...]
container rm [OPTIONS] CONTAINER [CONTAINER...]  # 短縮形
```

#### 主要オプション

| オプション | 説明 |
|------------|------|
| `--force` | 実行中のコンテナも強制削除 |

#### 使用例
```bash
# 停止中のコンテナを削除
container rm my-container

# 実行中のコンテナを強制削除
container rm --force my-container

# 複数のコンテナを削除
container rm container1 container2 container3
```

### container kill

実行中のコンテナにシグナルを送信します。

#### 基本構文
```bash
container kill [OPTIONS] CONTAINER [CONTAINER...]
```

#### 使用例
```bash
# SIGKILL で強制終了
container kill my-container

# 特定のシグナルを送信
container kill --signal SIGTERM my-container
```

## 2. イメージ管理コマンド

### container build

Dockerfileからイメージをビルドします。

#### 基本構文
```bash
container build [OPTIONS] PATH
```

#### 主要オプション

| オプション | 短縮形 | 説明 |
|------------|--------|------|
| `--tag` | `-t` | イメージ名とタグを指定 |
| `--file` | `-f` | Dockerfileのパスを指定 |
| `--arch` | - | ターゲットアーキテクチャを指定 |
| `--build-arg` | - | ビルド引数を設定 |

#### 使用例
```bash
# 基本的なビルド
container build -t my-app .

# 特定のDockerfileを使用
container build -t my-app -f Dockerfile.prod .

# マルチアーキテクチャビルド
container build --arch arm64 --arch amd64 -t my-app .

# ビルド引数を指定
container build --build-arg VERSION=1.0 --build-arg ENV=production -t my-app .
```

### container images list

ローカルのイメージ一覧を表示します。

#### 基本構文
```bash
container images list [OPTIONS]
```

#### 使用例
```bash
# イメージ一覧を表示
container images list

# JSON形式で出力
container images list --format json
```

### container images pull

レジストリからイメージを取得します。

#### 基本構文
```bash
container images pull [OPTIONS] IMAGE
```

#### 主要オプション

| オプション | 説明 |
|------------|------|
| `--platform` | プラットフォームを指定 |

#### 使用例
```bash
# イメージを取得
container images pull python:alpine

# 特定のプラットフォーム向けイメージを取得
container images pull --platform linux/arm64 python:alpine

# プライベートレジストリから取得
container images pull registry.example.com/my-app:latest
```

### container images push

イメージをレジストリにプッシュします。

#### 基本構文
```bash
container images push IMAGE
```

#### 使用例
```bash
# パブリックレジストリにプッシュ
container images push my-username/my-app:latest

# プライベートレジストリにプッシュ
container images push registry.example.com/my-app:latest
```

### container images tag

イメージにタグを付けます。

#### 基本構文
```bash
container images tag SOURCE_IMAGE TARGET_IMAGE
```

#### 使用例
```bash
# ローカルイメージにタグを付ける
container images tag my-app:latest my-app:v1.0

# レジストリ用のタグを作成
container images tag my-app:latest registry.example.com/my-app:latest
```

### container images save / load

イメージをファイルとして保存・読み込みします。

#### 基本構文
```bash
container images save [OPTIONS] IMAGE
container images load [OPTIONS]
```

#### 使用例
```bash
# イメージをファイルに保存
container images save --output my-app.tar my-app:latest

# ファイルからイメージを読み込み
container images load --input my-app.tar
```

### container images inspect

イメージの詳細情報を表示します。

#### 基本構文
```bash
container images inspect IMAGE [IMAGE...]
```

#### 使用例
```bash
# イメージの詳細情報を表示
container images inspect python:alpine

# 特定の情報を抽出
container images inspect python:alpine | jq '.architecture'
```

### container images rm

イメージを削除します。

#### 基本構文
```bash
container images rm [OPTIONS] IMAGE [IMAGE...]
```

#### 使用例
```bash
# イメージを削除
container images rm my-app:latest

# 複数のイメージを削除
container images rm image1 image2 image3

# すべてのイメージを削除
container images rm --all
```

## 3. システム管理コマンド

### container system

システム全体の管理を行います。

#### サブコマンド一覧

| サブコマンド | 説明 |
|--------------|------|
| `start` | システムサービスを開始 |
| `stop` | システムサービスを停止 |
| `restart` | システムサービスを再起動 |
| `status` | システム状態を表示 |
| `logs` | システムログを表示 |

#### 使用例
```bash
# システムを開始
container system start

# システムを停止
container system stop

# システムを再起動
container system restart

# システム状態を確認
container system status

# システムログを表示
container system logs
```

### container system dns

DNS設定を管理します。

#### サブコマンド一覧

| サブコマンド | 説明 |
|--------------|------|
| `create DOMAIN` | DNSドメインを作成 |
| `delete DOMAIN` | DNSドメインを削除 |
| `list` | DNS設定を一覧表示 |
| `default set DOMAIN` | デフォルトドメインを設定 |
| `default get` | デフォルトドメインを表示 |

#### 使用例
```bash
# DNSドメインを作成（管理者権限必要）
sudo container system dns create test

# デフォルトドメインを設定
container system dns default set test

# DNS設定を確認
container system dns list

# DNSドメインを削除
sudo container system dns delete test
```

### container system kernel

Linuxカーネルを管理します。

#### サブコマンド一覧

| サブコマンド | 説明 |
|--------------|------|
| `list` | インストール済みカーネルを一覧表示 |
| `set` | カーネルを設定 |

#### 使用例
```bash
# カーネル一覧を表示
container system kernel list

# 推奨カーネルをインストール
container system kernel set --recommended

# カスタムカーネルを設定
container system kernel set --binary /path/to/kernel

# tarアーカイブからカーネルをインストール
container system kernel set --tar /path/to/kernel.tar.xz
```

### container builder

ビルダーコンテナを管理します。

#### サブコマンド一覧

| サブコマンド | 説明 |
|--------------|------|
| `start` | ビルダーを開始 |
| `stop` | ビルダーを停止 |
| `delete` | ビルダーを削除 |
| `status` | ビルダー状態を表示 |

#### 使用例
```bash
# デフォルト設定でビルダーを開始
container builder start

# リソースを指定してビルダーを開始
container builder start --cpus 8 --memory 16g

# ビルダーの状態を確認
container builder status

# ビルダーを停止
container builder stop

# ビルダーを削除
container builder delete
```

### container registry

レジストリ設定を管理します。

#### サブコマンド一覧

| サブコマンド | 説明 |
|--------------|------|
| `login REGISTRY` | レジストリにログイン |
| `logout REGISTRY` | レジストリからログアウト |
| `default set REGISTRY` | デフォルトレジストリを設定 |
| `default get` | デフォルトレジストリを表示 |

#### 使用例
```bash
# レジストリにログイン
container registry login ghcr.io

# デフォルトレジストリを設定
container registry default set ghcr.io

# デフォルトレジストリを確認
container registry default get

# レジストリからログアウト
container registry logout ghcr.io
```

## 高度な使用例

### 複数コンテナの連携

```bash
# データベースコンテナを起動
container run -d --name database postgres:alpine

# アプリケーションコンテナを起動（データベースと連携）
container run -d --name app my-app

# アプリケーションからデータベースにアクセス
container exec app curl http://database.test:5432
```

### 開発環境の構築

```bash
# 開発用コンテナを起動（ボリュームマウント付き）
container run -it --name dev-env \
  -v ${PWD}:/workspace \
  -v ${HOME}/.ssh:/root/.ssh:ro \
  ubuntu:latest bash

# 開発環境内で作業
container exec -it dev-env bash
```

### CI/CDでの活用

```bash
# テスト用コンテナでビルドとテスト
container run --rm \
  -v ${PWD}:/app \
  -w /app \
  node:alpine \
  sh -c "npm install && npm test"

# ビルド結果をイメージとして保存
container build -t my-app:${BUILD_NUMBER} .
container images push my-app:${BUILD_NUMBER}
```

--- 

# 実践的な使用例

## 概要

このチャプターでは、Apple Containerを実際の開発現場で活用するための実践的な使用例を紹介します。基本的なコマンドの使い方を理解した後、より高度で実用的なシナリオを通じて、Apple Containerの真価を発揮する方法を学習していきます。

## 実践例の構成

このチャプターでは、以下の実践的なシナリオを扱います：

1. **リソース管理とパフォーマンス最適化**
2. **ボリュームマウントとデータ管理**
3. **マルチアーキテクチャ対応**
4. **開発環境の構築**
5. **CI/CDパイプラインでの活用**
6. **マイクロサービス開発**
7. **デバッグとトラブルシューティング**

各例では、実際のコマンドと設定を示しながら、なぜそのアプローチが効果的なのかを説明します。

## 1. リソース管理とパフォーマンス最適化

### メモリとCPUの適切な設定

Apple Containerでは、各コンテナが独立したVMで実行されるため、適切なリソース配分が重要です。

#### 軽量アプリケーションの場合

```bash
# 軽量なWebアプリケーション
container run -d --name light-app \
  --memory 512m \
  --cpus 1 \
  my-web-app:latest
```

#### 重い処理を行うアプリケーションの場合

```bash
# データ処理やビルド処理
container run -d --name heavy-app \
  --memory 8g \
  --cpus 6 \
  data-processing-app:latest
```

#### 動的なリソース調整

開発中にリソース要件が変わる場合は、コンテナを再作成します：

```bash
# 現在のコンテナを停止・削除
container stop my-app
container rm my-app

# より多くのリソースで再作成
container run -d --name my-app \
  --memory 4g \
  --cpus 4 \
  my-app:latest
```

### ビルダーのリソース最適化

大きなイメージをビルドする際は、ビルダーのリソースを調整します：

```bash
# 現在のビルダーを停止・削除
container builder stop
container builder delete

# 高性能ビルダーを起動
container builder start --cpus 8 --memory 32g

# 大きなプロジェクトをビルド
container build -t large-project:latest .
```

### リソース使用量の監視

```bash
# コンテナの詳細情報を確認
container inspect my-app | jq '.configuration.resources'

# システム全体の状態を確認
container system status
```

## 2. ボリュームマウントとデータ管理

### 開発時のソースコード同期

開発中は、ホストのソースコードをコンテナ内にマウントして、リアルタイムで変更を反映させます。

```bash
# Node.js開発環境
container run -it --name node-dev \
  -v ${PWD}:/app \
  -v ${PWD}/node_modules:/app/node_modules \
  -w /app \
  node:alpine \
  sh

# コンテナ内で開発サーバーを起動
npm install
npm run dev
```

### データベースのデータ永続化

```bash
# PostgreSQLコンテナでデータを永続化
container run -d --name postgres-db \
  -v ${HOME}/postgres-data:/var/lib/postgresql/data \
  -e POSTGRES_PASSWORD=mypassword \
  postgres:alpine
```

### 設定ファイルの管理

```bash
# 設定ファイルをマウント
container run -d --name web-server \
  -v ${PWD}/config/nginx.conf:/etc/nginx/nginx.conf:ro \
  -v ${PWD}/ssl:/etc/ssl/certs:ro \
  nginx:alpine
```

### 複数のボリュームマウント

```bash
# 複雑なアプリケーションの例
container run -d --name complex-app \
  -v ${PWD}/src:/app/src \
  -v ${PWD}/config:/app/config:ro \
  -v ${HOME}/app-data:/app/data \
  -v ${HOME}/app-logs:/app/logs \
  my-complex-app:latest
```

### mount オプションの活用

より詳細な制御が必要な場合は、`--mount` オプションを使用します：

```bash
container run -d --name secure-app \
  --mount source=${PWD}/data,target=/app/data,readonly \
  --mount source=${PWD}/config,target=/app/config,readonly \
  --mount source=${HOME}/app-cache,target=/app/cache \
  my-secure-app:latest
```

## 3. マルチアーキテクチャ対応

### マルチアーキテクチャイメージのビルド

Apple Silicon MacでAMD64向けのイメージも作成する場合：

```bash
# 両方のアーキテクチャ向けにビルド
container build \
  --arch arm64 \
  --arch amd64 \
  --tag my-app:multiarch \
  .

# 特定のアーキテクチャで実行
container run --arch arm64 my-app:multiarch
container run --arch amd64 my-app:multiarch  # Rosetta経由で実行
```

### アーキテクチャ固有のイメージ管理

```bash
# ARM64向けイメージを取得
container images pull --platform linux/arm64 python:alpine

# AMD64向けイメージを取得
container images pull --platform linux/amd64 python:alpine

# 現在のアーキテクチャを確認
container run --rm alpine uname -m
```

### クロスプラットフォーム開発

```bash
# AMD64環境での動作確認（Rosetta使用）
container run --arch amd64 --rm my-app:latest test-suite

# ARM64での最適化確認
container run --arch arm64 --rm my-app:latest benchmark
```

## 4. 開発環境の構築

### フルスタック開発環境

複数のサービスを組み合わせた開発環境を構築します：

```bash
# データベース
container run -d --name dev-db \
  -v ${PWD}/db-data:/var/lib/postgresql/data \
  -e POSTGRES_DB=myapp \
  -e POSTGRES_USER=developer \
  -e POSTGRES_PASSWORD=devpass \
  postgres:alpine

# Redis
container run -d --name dev-redis \
  redis:alpine

# アプリケーション
container run -d --name dev-app \
  -v ${PWD}:/app \
  -w /app \
  --memory 2g \
  --cpus 2 \
  node:alpine \
  npm run dev

# 各サービスのIPアドレスを確認
container ls
```

### 開発ツールコンテナ

```bash
# 開発ツール一式を含むコンテナ
container run -it --name dev-tools \
  -v ${PWD}:/workspace \
  -v ${HOME}/.ssh:/root/.ssh:ro \
  -v ${HOME}/.gitconfig:/root/.gitconfig:ro \
  -w /workspace \
  ubuntu:latest bash

# コンテナ内で必要なツールをインストール
apt update && apt install -y git curl vim build-essential
```

### 言語固有の開発環境

#### Python開発環境

```bash
# Python開発環境
container run -it --name python-dev \
  -v ${PWD}:/app \
  -v ${HOME}/.cache/pip:/root/.cache/pip \
  -w /app \
  python:3.11 bash

# 仮想環境とパッケージのインストール
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
```

#### Go開発環境

```bash
# Go開発環境
container run -it --name go-dev \
  -v ${PWD}:/go/src/myapp \
  -v ${HOME}/go/pkg:/go/pkg \
  -w /go/src/myapp \
  -e GOPROXY=https://proxy.golang.org \
  golang:alpine bash

# モジュールの初期化とビルド
go mod init myapp
go mod tidy
go build
```

## 5. CI/CDパイプラインでの活用

### 自動テスト環境

```bash
# テスト専用コンテナでユニットテスト
container run --rm \
  -v ${PWD}:/app \
  -w /app \
  --memory 4g \
  node:alpine \
  sh -c "npm ci && npm test"

# 統合テスト用の環境構築
container run -d --name test-db \
  -e POSTGRES_DB=testdb \
  -e POSTGRES_USER=test \
  -e POSTGRES_PASSWORD=test \
  postgres:alpine

container run --rm \
  -v ${PWD}:/app \
  -w /app \
  --memory 4g \
  node:alpine \
  sh -c "npm ci && npm run test:integration"

# テスト後のクリーンアップ
container stop test-db
container rm test-db
```

### ビルドパイプライン

```bash
#!/bin/bash
# build-pipeline.sh

set -e

# 環境変数の設定
BUILD_NUMBER=${BUILD_NUMBER:-$(date +%Y%m%d-%H%M%S)}
IMAGE_NAME="my-app"
REGISTRY="registry.example.com"

# ビルダーの準備
container builder start --cpus 8 --memory 16g

# イメージのビルド
container build \
  --tag ${IMAGE_NAME}:${BUILD_NUMBER} \
  --tag ${IMAGE_NAME}:latest \
  .

# テストの実行
container run --rm \
  -v ${PWD}/tests:/tests \
  ${IMAGE_NAME}:${BUILD_NUMBER} \
  /tests/run-tests.sh

# レジストリにプッシュ
container images tag ${IMAGE_NAME}:${BUILD_NUMBER} ${REGISTRY}/${IMAGE_NAME}:${BUILD_NUMBER}
container images tag ${IMAGE_NAME}:latest ${REGISTRY}/${IMAGE_NAME}:latest

container images push ${REGISTRY}/${IMAGE_NAME}:${BUILD_NUMBER}
container images push ${REGISTRY}/${IMAGE_NAME}:latest

echo "Build completed: ${REGISTRY}/${IMAGE_NAME}:${BUILD_NUMBER}"
```

### デプロイメント検証

```bash
# 新しいイメージでの動作確認
container run -d --name staging-test \
  --memory 2g \
  --cpus 2 \
  registry.example.com/my-app:${BUILD_NUMBER}

# ヘルスチェック
sleep 30
container exec staging-test curl -f http://localhost:8080/health

# 問題なければ本番用タグを付与
if [ $? -eq 0 ]; then
  container images tag registry.example.com/my-app:${BUILD_NUMBER} registry.example.com/my-app:production
  container images push registry.example.com/my-app:production
fi

# ステージング環境のクリーンアップ
container stop staging-test
container rm staging-test
```

## 6. マイクロサービス開発

### サービス間通信の設定

```bash
# API Gateway
container run -d --name api-gateway \
  --memory 1g \
  --cpus 2 \
  my-api-gateway:latest

# User Service
container run -d --name user-service \
  --memory 2g \
  --cpus 2 \
  my-user-service:latest

# Order Service
container run -d --name order-service \
  --memory 2g \
  --cpus 2 \
  my-order-service:latest

# 各サービスのIPアドレスを確認
container ls --format json | jq '.[] | {name: .configuration.id, ip: .networks[0].address}'
```

### サービス発見の活用

DNS設定を使用してサービス間通信を簡素化：

```bash
# DNS設定（事前に設定済みと仮定）
# sudo container system dns create microservices
# container system dns default set microservices

# サービス間でDNS名を使用した通信
container exec api-gateway curl http://user-service.microservices:8080/users
container exec api-gateway curl http://order-service.microservices:8080/orders
```

### 開発用のサービスメッシュ

```bash
# 各サービスを起動（DNS名付き）
container run -d --name user-service --dns-domain microservices my-user-service:latest
container run -d --name order-service --dns-domain microservices my-order-service:latest
container run -d --name payment-service --dns-domain microservices my-payment-service:latest

# API Gatewayから各サービスにアクセス
container run -d --name api-gateway --dns-domain microservices \
  -e USER_SERVICE_URL=http://user-service.microservices:8080 \
  -e ORDER_SERVICE_URL=http://order-service.microservices:8080 \
  -e PAYMENT_SERVICE_URL=http://payment-service.microservices:8080 \
  my-api-gateway:latest
```

## 7. デバッグとトラブルシューティング

### デバッグ用コンテナの起動

```bash
# デバッグモードでアプリケーションを起動
container run -it --name debug-app \
  -v ${PWD}:/app \
  -w /app \
  --memory 4g \
  -e DEBUG=true \
  -e LOG_LEVEL=debug \
  my-app:latest bash

# デバッガーポートを公開（必要に応じて）
container run -it --name debug-app \
  -v ${PWD}:/app \
  -w /app \
  my-app:latest \
  node --inspect=0.0.0.0:9229 app.js
```

### ログの詳細分析

```bash
# アプリケーションログの確認
container logs my-app

# ブートログの確認（VM起動時の問題を調査）
container logs --boot my-app

# リアルタイムでログを監視
container logs --follow my-app

# システムログの確認
container system logs
```

### パフォーマンス分析

```bash
# コンテナ内でのリソース使用状況確認
container exec my-app top
container exec my-app free -h
container exec my-app df -h

# ネットワーク接続の確認
container exec my-app netstat -tlnp
container exec my-app ss -tlnp
```

### 問題の切り分け

```bash
# 最小構成でのテスト
container run --rm -it alpine sh

# ネットワーク接続のテスト
container run --rm alpine ping 8.8.8.8
container run --rm alpine nslookup google.com

# 他のコンテナとの通信テスト
container run --rm alpine ping 192.168.64.3
```

### デバッグ情報の収集

```bash
# システム情報の収集
container system status > debug-info.txt
container system logs >> debug-info.txt

# コンテナ情報の収集
container ls --format json > containers.json
container inspect my-app > container-details.json

# イメージ情報の収集
container images list --format json > images.json
```

## 8. 高度な運用パターン

### ブルーグリーンデプロイメント

```bash
# 現在のバージョン（Blue）
container run -d --name app-blue my-app:v1.0

# 新しいバージョン（Green）をテスト
container run -d --name app-green my-app:v2.0

# 新バージョンの動作確認
container exec app-green curl -f http://localhost:8080/health

# 問題なければ切り替え
container stop app-blue
container rm app-blue
container run -d --name app-blue my-app:v2.0
container stop app-green
container rm app-green
```

### カナリアデプロイメント

```bash
# 本番バージョン（90%のトラフィック）
container run -d --name app-stable my-app:v1.0

# カナリアバージョン（10%のトラフィック）
container run -d --name app-canary my-app:v2.0

# 両方のバージョンを監視
container logs --follow app-stable &
container logs --follow app-canary &

# 問題なければ段階的に切り替え
```

### バックアップとリストア

```bash
# データのバックアップ
container run --rm \
  -v ${HOME}/app-data:/data \
  -v ${HOME}/backups:/backup \
  alpine \
  tar czf /backup/app-data-$(date +%Y%m%d).tar.gz -C /data .

# イメージのバックアップ
container images save --output my-app-backup.tar my-app:latest

# リストア
container images load --input my-app-backup.tar
```

---

# ネットワーキングとDNS

## 概要

このチャプターでは、Apple Containerのネットワーキング機能について詳しく学習します。Apple Containerは、macOSのvmnetフレームワークを使用して仮想ネットワークを構築し、各コンテナに独立したIPアドレスを割り当てます。また、DNS機能により、IPアドレスの代わりにホスト名でコンテナにアクセスできる便利な機能も提供しています。

## ネットワーキングの基本概念

### Apple Containerのネットワークアーキテクチャ

Apple Containerは、従来のDockerとは異なる独自のネットワークアーキテクチャを採用しています。各コンテナが軽量VMとして実行されるため、ネットワークも仮想化されたアプローチを取っています。

> **技術的背景**: このネットワークアーキテクチャは、containerizationシステムのVirtualMachineManagerとmacOSのvmnetフレームワークの連携により実現されています。各VMは独立したネットワークスタックを持ち、ホストとの通信はvsock（仮想ソケット）を通じて行われます。これにより、従来のコンテナ技術では実現困難な、真の分離性とセキュリティを提供します。

```
macOS Host (192.168.1.x)
    │
    ├── bridge100 (仮想ブリッジ)
    │   └── 192.168.64.1 (ゲートウェイ)
    │
    ├── Container VM 1: 192.168.64.10
    ├── Container VM 2: 192.168.64.11
    ├── Container VM 3: 192.168.64.12
    └── ...
```

### ネットワークの特徴

| 特徴 | 説明 |
|------|------|
| **仮想ネットワーク** | 192.168.64.0/24 サブネット |
| **自動IP割り当て** | DHCPによる動的IP配布 |
| **NAT接続** | 外部インターネットへのアクセス |
| **DNS解決** | .test ドメインでのホスト名解決 |
| **VM分離** | 各コンテナが独立したネットワークスタック |

## ネットワーク設定の確認

### 基本的なネットワーク情報の確認

まず、現在のネットワーク設定を確認してみましょう。

```bash
# システムを起動
container system start

# ネットワークインターフェースの確認
ifconfig | grep bridge
```

出力例：
```
bridge100: flags=8863<UP,BROADCAST,SMART,RUNNING,SIMPLEX,MULTICAST> mtu 1500
	inet 192.168.64.1 netmask 0xffffff00 broadcast 192.168.64.255
```

### コンテナのネットワーク情報確認

```bash
# テスト用コンテナを起動
container run -d --name network-test alpine sleep 3600

# コンテナ一覧でIPアドレスを確認
container ls

# 詳細なネットワーク情報を確認
container inspect network-test | jq '.networks[0]'
```

出力例：
```json
{
  "address": "192.168.64.10",
  "gateway": "192.168.64.1",
  "interface": "eth0"
}
```

## IPアドレスの管理

### IPアドレスの割り当て方式

Apple Containerは、以下の方式でIPアドレスを管理しています：

1. **ゲートウェイ**: 192.168.64.1（固定）
2. **DHCP範囲**: 192.168.64.10 ～ 192.168.64.254
3. **自動割り当て**: コンテナ起動時に利用可能な最小のIPを割り当て

### IPアドレスの確認方法

```bash
# 複数のコンテナを起動してIP割り当てを確認
container run -d --name test1 alpine sleep 3600
container run -d --name test2 alpine sleep 3600
container run -d --name test3 alpine sleep 3600

# 各コンテナのIPアドレスを確認
container ls --format json | jq '.[] | {name: .configuration.id, ip: .networks[0].address}'
```

出力例：
```json
{
  "name": "test1",
  "ip": "192.168.64.10"
}
{
  "name": "test2",
  "ip": "192.168.64.11"
}
{
  "name": "test3",
  "ip": "192.168.64.12"
}
```

### ネットワーク接続のテスト

```bash
# コンテナ間の通信テスト
container exec test1 ping -c 3 192.168.64.11

# ゲートウェイへの接続テスト
container exec test1 ping -c 3 192.168.64.1

# 外部インターネットへの接続テスト
container exec test1 ping -c 3 8.8.8.8
```

## DNS設定と管理

### DNS機能の概要

Apple ContainerのDNS機能により、以下のことが可能になります：

- コンテナ名でのアクセス（例：`my-app.test`）
- IPアドレスを覚える必要がない
- サービス発見の簡素化
- 開発環境での利便性向上

### DNS設定の手順

#### 1. DNSドメインの作成

```bash
# testドメインを作成（管理者権限が必要）
sudo container system dns create test
```

このコマンドは以下の処理を行います：
- `/etc/resolver/test` ファイルの作成
- macOSのDNSリゾルバーにtest ドメインを登録
- Apple ContainerのDNSサービスへの転送設定

#### 2. デフォルトDNSドメインの設定

```bash
# testをデフォルトドメインに設定
container system dns default set test
```

#### 3. DNS設定の確認

```bash
# DNS設定の一覧表示
container system dns list

# デフォルトドメインの確認
container system dns default get
```

### DNS機能の実践

#### コンテナの起動とDNSテスト

```bash
# Webサーバーコンテナを起動
container run -d --name web-server nginx:alpine

# DNSでのアクセステスト
container run --rm alpine nslookup web-server.test

# HTTPアクセステスト
container run --rm alpine wget -qO- http://web-server.test
```

#### 複数サービスでのDNS活用

```bash
# データベースサービス
container run -d --name database postgres:alpine

# アプリケーションサービス
container run -d --name app my-app:latest

# API Gatewayサービス
container run -d --name gateway nginx:alpine

# サービス間通信のテスト
container exec app curl http://database.test:5432
container exec gateway curl http://app.test:8080
```

### カスタムDNSドメインの作成

開発プロジェクトごとに異なるDNSドメインを使用することも可能です：

```bash
# プロジェクト専用ドメインを作成
sudo container system dns create myproject

# プロジェクト用コンテナを起動
container run -d --name api --dns-domain myproject my-api:latest
container run -d --name frontend --dns-domain myproject my-frontend:latest

# プロジェクト内でのアクセス
container exec frontend curl http://api.myproject:8080/users
```

## ネットワークトラブルシューティング

### よくある問題と解決方法

#### 1. コンテナ間通信ができない

**症状**: コンテナ同士でpingやHTTP通信ができない

**確認手順**:
```bash
# ネットワーク設定の確認
container ls
container inspect container1 | jq '.networks[0]'
container inspect container2 | jq '.networks[0]'

# 基本的な接続テスト
container exec container1 ping 192.168.64.1  # ゲートウェイ
container exec container1 ping 192.168.64.11  # 他のコンテナ
```

**解決方法**:
- macOS 15の場合、ネットワーク制限により通信が制限される可能性
- システムの再起動を試行
- ファイアウォール設定の確認

#### 2. DNS解決ができない

**症状**: `container-name.test` でアクセスできない

**確認手順**:
```bash
# DNS設定の確認
container system dns list
ls -la /etc/resolver/

# DNS解決テスト
container run --rm alpine nslookup my-container.test
```

**解決方法**:
```bash
# DNS設定の再作成
sudo container system dns delete test
sudo container system dns create test
container system dns default set test
```

#### 3. 外部インターネットにアクセスできない

**症状**: コンテナから外部サイトにアクセスできない

**確認手順**:
```bash
# 基本的な接続テスト
container exec my-container ping 8.8.8.8
container exec my-container nslookup google.com
container exec my-container curl -I https://www.google.com
```

**解決方法**:
- ホストのインターネット接続を確認
- プロキシ設定が必要な環境では、コンテナ内でプロキシ設定
- VPN接続が影響している場合は、VPN設定を確認

### macOS 15での制限事項

macOS 15では、以下の制限があります：

#### コンテナ間通信の制限

```bash
# macOS 15での問題確認
container run -d --name test1 alpine sleep 3600
container run -d --name test2 alpine sleep 3600

# 通信テスト（失敗する可能性）
container exec test1 ping 192.168.64.11
```

#### ネットワーク設定の手動調整

```bash
# システムを停止
container system stop

# サブネット設定を変更
defaults write com.apple.container.defaults network.subnet 192.168.66.1/24

# システムを再起動
container system start

# 新しい設定の確認
ifconfig | grep bridge
```

## 高度なネットワーク設定

### ホストサービスへのアクセス

コンテナからホストのサービスにアクセスする場合、`socat` を使用したポートフォワーディングが必要です。

#### socatを使用したポートフォワーディング

```bash
# ホストでWebサーバーを起動（例：localhost:8000）
python3 -m http.server 8000

# 別のターミナルでsocatを起動
socat TCP-LISTEN:8000,fork,bind=192.168.64.1 TCP:127.0.0.1:8000

# コンテナからアクセス
container run --rm alpine wget -qO- http://192.168.64.1:8000
```

### ポートマッピングの代替手段

Apple Containerには従来のDockerのような `-p` オプションはありませんが、以下の方法でアクセスできます：

#### 1. 直接IPアクセス

```bash
# Webサーバーを起動
container run -d --name web nginx:alpine

# ホストからブラウザでアクセス
open http://192.168.64.10
```

#### 2. DNS名でのアクセス

```bash
# DNS設定済みの場合
open http://web.test
```

### ネットワークセキュリティ

#### ファイアウォール設定

```bash
# macOSファイアウォールの状態確認
sudo /usr/libexec/ApplicationFirewall/socketfilterfw --getglobalstate

# 必要に応じてファイアウォール設定を調整
sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setglobalstate off
```

#### ネットワーク分離

```bash
# 異なるDNSドメインでサービスを分離
sudo container system dns create production
sudo container system dns create development

# 本番環境
container run -d --name prod-api --dns-domain production my-api:latest

# 開発環境
container run -d --name dev-api --dns-domain development my-api:dev
```

## ネットワーク監視とデバッグ

### ネットワーク状態の監視

```bash
# ネットワークインターフェースの監視
watch -n 1 'ifconfig bridge100'

# コンテナのネットワーク統計
container exec my-container cat /proc/net/dev

# ネットワーク接続の確認
container exec my-container netstat -tuln
```

### パケットキャプチャ

```bash
# tcpdumpでパケットをキャプチャ（ホスト側）
sudo tcpdump -i bridge100 -n

# コンテナ内でのネットワーク診断
container exec my-container ss -tuln
container exec my-container ip route show
```

### ネットワークパフォーマンステスト

```bash
# 帯域幅テスト用のコンテナを起動
container run -d --name iperf-server networkstatic/iperf3 -s

# クライアントからテスト
container run --rm networkstatic/iperf3 -c 192.168.64.10 -t 10
```

## 実践的なネットワーク活用例

### マイクロサービスアーキテクチャ

```bash
# サービスメッシュの構築
container run -d --name user-service my-user-service:latest
container run -d --name order-service my-order-service:latest
container run -d --name payment-service my-payment-service:latest

# API Gateway
container run -d --name api-gateway \
  -e USER_SERVICE_URL=http://user-service.test:8080 \
  -e ORDER_SERVICE_URL=http://order-service.test:8080 \
  -e PAYMENT_SERVICE_URL=http://payment-service.test:8080 \
  my-api-gateway:latest

# サービス間通信のテスト
container exec api-gateway curl http://user-service.test:8080/health
container exec api-gateway curl http://order-service.test:8080/health
```

### 負荷分散の実装

```bash
# 複数のアプリケーションインスタンス
container run -d --name app1 my-app:latest
container run -d --name app2 my-app:latest
container run -d --name app3 my-app:latest

# 簡易ロードバランサー（nginx設定）
cat > nginx.conf << 'EOF'
upstream backend {
    server app1.test:8080;
    server app2.test:8080;
    server app3.test:8080;
}

server {
    listen 80;
    location / {
        proxy_pass http://backend;
    }
}
EOF

# ロードバランサーを起動
container run -d --name load-balancer \
  -v ${PWD}/nginx.conf:/etc/nginx/conf.d/default.conf \
  nginx:alpine
```

### 開発環境とステージング環境の分離

```bash
# 開発環境用DNS
sudo container system dns create dev

# ステージング環境用DNS
sudo container system dns create staging

# 開発環境のサービス
container run -d --name api --dns-domain dev my-api:dev
container run -d --name frontend --dns-domain dev my-frontend:dev

# ステージング環境のサービス
container run -d --name api --dns-domain staging my-api:staging
container run -d --name frontend --dns-domain staging my-frontend:staging

# 環境ごとのアクセス
curl http://api.dev:8080/status
curl http://api.staging:8080/status
```