MENU
  1. ホーム
  2. Go
  3. Goプロジェクトの依存関係をDockerで管理する方法：サードパーティパッケージ対応

Goプロジェクトの依存関係をDockerで管理する方法：サードパーティパッケージ対応

Go

Goプロジェクトを開発する際、依存関係の管理は非常に重要です。Go言語は、シンプルで効率的なプログラミング体験を提供する一方で、外部ライブラリやツールを使用するプロジェクトでは依存関係管理の複雑さに直面することがあります。この問題に対処するため、Dockerを活用することで環境の一貫性を保ちつつ、依存関係の管理を簡素化できます。本記事では、Goプロジェクトでサードパーティパッケージを含む場合の依存関係を、Dockerを使用して効率的に管理する方法を解説します。これにより、開発環境と本番環境での動作の一貫性を確保し、開発効率を向上させることができます。

目次
  1. Go言語の依存関係管理の重要性
    1. 依存関係管理の課題
    2. Goモジュールによる依存管理
    3. Dockerを活用した依存管理の強化
  2. Dockerの基礎とGoプロジェクトとの連携
    1. Dockerとは何か
    2. DockerがGoプロジェクトに適している理由
    3. GoプロジェクトでのDockerの利用シーン
  3. 必要なツールと環境構築
    1. 必要なツール
    2. 環境構築の手順
    3. セットアップ完了後の確認
  4. Dockerfileの作成と解説
    1. Dockerfileの構造
    2. 各ステップの解説
    3. このDockerfileの特徴
    4. 実行方法
  5. サードパーティパッケージのインストール方法
    1. パッケージインストールの基本手順
    2. 依存パッケージのテスト
    3. ベストプラクティス
    4. 例：サードパーティパッケージを利用したコード
  6. コンテナ化されたGoアプリケーションのビルド
    1. 1. プロジェクトの準備
    2. 2. Dockerfileの作成
    3. 3. Dockerイメージのビルド
    4. 4. コンテナの起動とテスト
    5. 5. ビルドの最適化ポイント
    6. サンプルコード
  7. トラブルシューティングとベストプラクティス
    1. トラブルシューティング
    2. ベストプラクティス
    3. よくある問題とその解決例
    4. まとめ
  8. 実践例：小規模WebアプリケーションのDocker化
    1. アプリケーションの概要
    2. プロジェクトの構造
    3. 1. アプリケーションコードの作成
    4. 2. Goモジュールの初期化
    5. 3. Dockerfileの作成
    6. 4. Dockerイメージのビルド
    7. 5. コンテナの起動
    8. 6. トラブルシューティング
    9. 7. 応用：Docker Composeの利用
    10. まとめ
  9. まとめ

Go言語の依存関係管理の重要性


Go言語は、開発者にシンプルで効率的な開発環境を提供する一方で、プロジェクトの依存関係管理において独自の課題があります。依存関係とは、プロジェクトが利用する外部ライブラリやモジュールのことを指し、これらを適切に管理しないと、次のような問題が発生します。

依存関係管理の課題

  • 環境の不一致：開発者間で使用する依存パッケージのバージョンが異なると、動作が不安定になります。
  • ライブラリの更新リスク：外部ライブラリのバージョンアップにより、既存のコードが動作しなくなる可能性があります。
  • 配布の複雑化：特定の環境でしか動作しないプロジェクトは、運用や保守が難しくなります。

Goモジュールによる依存管理


Go 1.11以降、Goモジュール（go.modとgo.sumファイル）を利用した依存関係管理が標準化されました。これにより、以下が可能になります：

  • 依存パッケージの明示的な定義
  • バージョン固定による安定性の確保
  • 必要なライブラリを自動的にダウンロード

Dockerを活用した依存管理の強化


Dockerを組み合わせることで、依存関係の管理をさらに強化できます。Dockerは、環境全体をコンテナ化することで、以下の利点をもたらします：

  • 環境の一貫性：開発、テスト、本番環境で同じ依存環境を再現可能。
  • セットアップの簡略化：複数の依存を事前設定済みのイメージで管理。
  • 配布の簡易化：Dockerイメージとしてパッケージ化することで、容易に共有可能。

GoモジュールとDockerを組み合わせることで、依存管理の複雑さを大幅に削減し、開発効率を高めることが可能です。

Dockerの基礎とGoプロジェクトとの連携

Dockerは、アプリケーションとその依存関係をコンテナとしてパッケージ化し、一貫した環境で実行するためのプラットフォームです。GoプロジェクトとDockerを組み合わせることで、開発効率を高めるだけでなく、依存関係や環境設定に起因する問題を解消することができます。

Dockerとは何か


Dockerは、次のような特性を持つツールです：

  • 軽量な仮想化：OS全体を仮想化するのではなく、プロセスレベルで仮想化を行い、軽量なコンテナを実現します。
  • イミュータブル環境：一度作成したコンテナは変更されず、同じ環境をいつでも再現可能です。
  • ポータビリティ：異なる環境間（開発、テスト、本番）で同じ設定を共有できます。

DockerがGoプロジェクトに適している理由


GoプロジェクトにDockerを導入することで、以下のような利点があります：

  • 依存関係の分離：Goモジュールやサードパーティライブラリをコンテナ内に閉じ込め、ホストシステムとの干渉を防ぎます。
  • 環境の一貫性：すべての開発者が同じ環境で作業できるため、「動く環境」と「動かない環境」の差をなくします。
  • 効率的なビルドとデプロイ：Goの静的バイナリ特性とDockerのシンプルなイメージ構造が相性抜群です。

GoプロジェクトでのDockerの利用シーン

  1. 開発環境の構築：依存パッケージやツールを含む開発環境を簡単に共有。
  2. 本番環境の構築：本番環境と同じDockerイメージを使うことで、動作の再現性を確保。
  3. CI/CDパイプラインの最適化：コンテナ化されたアプリケーションを使用してテストやデプロイを自動化。

DockerをGoプロジェクトと連携させることで、従来の依存関係管理の課題を解消し、よりスムーズな開発プロセスを実現できます。

必要なツールと環境構築

Dockerを使用してGoプロジェクトを管理するには、いくつかのツールを準備し、環境を整える必要があります。以下では、必要なツールとセットアップ手順を解説します。

必要なツール

  1. Docker
  • コンテナを作成し、依存関係を管理するための基盤ツールです。
  • インストール方法は公式サイト（Docker公式サイト）を参照してください。
  1. Go言語開発環境
  • Dockerでの利用が中心ですが、ローカルにもGoのインストールがあると便利です。
  • インストール方法は公式サイト（Go公式サイト）を参照してください。
  1. コードエディタ
  • VS CodeやGoLandなど、Go開発に適したエディタを使用すると効率的です。
  1. Docker Compose（任意）
  • 複数のコンテナを扱う場合に役立つツールです。

環境構築の手順

1. Dockerのインストール

  • Docker Desktop（Windows/Mac）またはDocker Engine（Linux）をインストールします。
  • インストール後、docker --versionコマンドで正しくインストールされているか確認してください。

2. プロジェクトディレクトリの作成


プロジェクトのフォルダ構造を作成します。以下は典型的なGoプロジェクトの構造例です：

my-go-app/
├── Dockerfile
├── go.mod
├── go.sum
├── main.go
└── README.md

3. Goモジュールの初期化


go mod init my-go-appコマンドでGoモジュールを初期化します。これにより、go.modファイルが生成されます。

4. Dockerの動作確認


以下のコマンドを使用して、Dockerが正常に動作するかを確認します：

docker run hello-world

5. 必要な依存パッケージのインストール


go getコマンドを使用して、必要なサードパーティパッケージをインストールし、go.modに記録されていることを確認します。

セットアップ完了後の確認

  • Dockerfileの雛形を作成し、コンテナでGoプログラムをビルドできるか試してみます。
  • 環境の一貫性を確認するため、異なる環境で動作テストを行います。

適切なツールと環境を整えることで、GoプロジェクトのDocker化をスムーズに進められるようになります。

Dockerfileの作成と解説

Dockerfileは、Dockerコンテナのビルド手順を記述するファイルです。GoプロジェクトをDocker化するには、依存関係の管理とアプリケーションのビルド・実行を考慮したDockerfileを作成する必要があります。以下では、基本的なDockerfileの作成例とその解説を行います。

Dockerfileの構造


以下は、典型的なGoプロジェクト用のDockerfileの例です：

# ベースイメージを指定
FROM golang:1.20 AS builder

# 作業ディレクトリを作成
WORKDIR /app

# モジュール定義とソースコードをコピー
COPY go.mod go.sum ./
RUN go mod download

# ソースコードを追加コピー
COPY . .

# Goアプリケーションをビルド
RUN go build -o main .

# 実行用の軽量イメージを指定
FROM alpine:latest

# 作業ディレクトリを作成
WORKDIR /root/

# ビルド済みバイナリをコピー
COPY --from=builder /app/main .

# アプリケーションを実行
CMD ["./main"]

各ステップの解説

1. ベースイメージの選択

FROM golang:1.20 AS builder
  • golang:1.20はGoの公式イメージで、ビルド用のツールがあらかじめインストールされています。
  • AS builderはマルチステージビルドのための名前を定義しています。

2. 作業ディレクトリの設定

WORKDIR /app
  • コンテナ内の作業ディレクトリを指定します。これにより、すべてのコマンドがこのディレクトリ内で実行されます。

3. 依存関係のダウンロード

COPY go.mod go.sum ./
RUN go mod download
  • go.modとgo.sumをコンテナにコピーし、go mod downloadで依存パッケージをダウンロードします。

4. ソースコードのコピーとビルド

COPY . .
RUN go build -o main .
  • プロジェクトのソースコードをすべてコピーし、go buildで静的バイナリをビルドします。

5. 実行用の軽量イメージを使用

FROM alpine:latest
  • 実行環境を軽量化するため、Alpine Linuxを使用します。

6. ビルド済みバイナリの移動と実行

COPY --from=builder /app/main .
CMD ["./main"]
  • ビルド用コンテナから生成されたバイナリを実行用コンテナにコピーし、デフォルトのコマンドとして設定します。

このDockerfileの特徴

  • マルチステージビルド：ビルド環境と実行環境を分離することで、コンテナサイズを削減。
  • 一貫性の確保：依存関係やGoバージョンを明示的に指定。
  • 軽量化：Alpine Linuxを使用することで、最終的なイメージを最小化。

実行方法


Dockerfileを作成後、以下のコマンドでコンテナをビルド・実行します：

docker build -t my-go-app .
docker run -it --rm my-go-app

この手順で、Dockerコンテナ内で安定したGoアプリケーション環境を構築できます。

サードパーティパッケージのインストール方法

Goプロジェクトでは、サードパーティパッケージを利用して機能を拡張することが一般的です。Dockerを使用することで、依存パッケージを確実に管理し、プロジェクトの再現性を向上させることができます。ここでは、Docker環境でのサードパーティパッケージのインストール方法を解説します。

パッケージインストールの基本手順

1. 必要なモジュールを指定する


Goモジュールファイル（go.mod）に必要なサードパーティパッケージを追加します。例えば、HTTPサーバーの構築に便利なgithub.com/gorilla/muxを利用する場合：

go get github.com/gorilla/mux

このコマンドを実行すると、go.modに依存パッケージが記録され、go.sumにそのバージョン情報が追加されます。

2. Dockerfileに依存パッケージのダウンロードを組み込む


依存関係をDockerイメージに含めるため、go.modとgo.sumをDockerfileでコピーし、go mod downloadを実行します。

以下のDockerfileスニペットを参考にしてください：

# ベースイメージを指定
FROM golang:1.20 AS builder

# 作業ディレクトリを作成
WORKDIR /app

# モジュールファイルをコピー
COPY go.mod go.sum ./

# 依存パッケージをダウンロード
RUN go mod download

# ソースコードをコピー
COPY . .

# プロジェクトをビルド
RUN go build -o main .

3. コンテナ内での依存パッケージ管理


コンテナ内でgo mod downloadを実行することで、依存パッケージがダウンロードされます。このプロセスにより、プロジェクトの依存関係が明示的に管理され、開発環境や本番環境の間で一致します。

依存パッケージのテスト

Dockerコンテナで正しくインストールされたことを確認するため、以下のようにテストを行います：

1. Dockerイメージのビルド

docker build -t my-go-app .

2. コンテナを起動して動作確認


以下のコマンドでアプリケーションを実行し、サードパーティパッケージが正しく動作しているか確認します：

docker run -it --rm my-go-app

ベストプラクティス

  1. バージョン固定
  • 依存するパッケージのバージョンを固定することで、更新による予期しない動作変更を防ぎます。
  1. キャッシュの活用
  • Dockerfileでgo.modとgo.sumを早い段階でコピーすることで、依存関係の変更がない限り、パッケージのダウンロードをキャッシュします。これによりビルド速度が向上します。
  1. 最小限の依存
  • プロジェクトで実際に必要なパッケージのみを使用し、依存性を軽減します。

例：サードパーティパッケージを利用したコード

以下は、github.com/gorilla/muxを使った簡単なHTTPサーバーの例です：

package main

import (
    "fmt"
    "net/http"

    "github.com/gorilla/mux"
)

func main() {
    r := mux.NewRouter()
    r.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Hello, World!")
    })
    http.ListenAndServe(":8080", r)
}

このコードをコンテナ化すれば、サードパーティパッケージを使用したGoアプリケーションがDocker環境で再現可能になります。

コンテナ化されたGoアプリケーションのビルド

Dockerを利用してGoアプリケーションをコンテナ化することで、環境間での一貫性を保ちつつ、簡単にデプロイ可能なアプリケーションを構築できます。ここでは、コンテナ化されたGoアプリケーションをビルドする手順を解説します。

1. プロジェクトの準備

必要なファイルを揃える


以下のファイル構造をプロジェクト内に準備します：

my-go-app/
├── Dockerfile
├── go.mod
├── go.sum
├── main.go
  • go.modとgo.sum：依存関係を管理するGoモジュールファイル。
  • main.go：アプリケーションのエントリーポイント。
  • Dockerfile：コンテナビルドの設定ファイル。

2. Dockerfileの作成

以下の内容でDockerfileを作成します：

# ビルド用のベースイメージ
FROM golang:1.20 AS builder

# 作業ディレクトリを作成
WORKDIR /app

# Goモジュールファイルをコピーして依存関係をダウンロード
COPY go.mod go.sum ./
RUN go mod download

# ソースコードをコピーしてビルド
COPY . .
RUN go build -o main .

# 実行環境用の軽量イメージ
FROM alpine:latest
WORKDIR /root/
COPY --from=builder /app/main .

# アプリケーションをデフォルトコマンドとして設定
CMD ["./main"]

3. Dockerイメージのビルド

Dockerfileを基にDockerイメージをビルドします。以下のコマンドを実行します：

docker build -t my-go-app .
  • -t my-go-app：イメージにmy-go-appという名前を付けます。
  • .：現在のディレクトリをビルドコンテキストとして指定します。

ビルドが成功すると、イメージが作成されます。

4. コンテナの起動とテスト

ビルドしたイメージを基にコンテナを起動し、アプリケーションの動作を確認します：

docker run -it --rm -p 8080:8080 my-go-app
  • -it：対話形式でコンテナを起動します。
  • --rm：コンテナ終了時に自動的に削除します。
  • -p 8080:8080：ホストの8080ポートをコンテナの8080ポートにマッピングします。

ブラウザでhttp://localhost:8080にアクセスし、アプリケーションが正しく動作しているか確認します。

5. ビルドの最適化ポイント

  • キャッシュの活用
    DockerfileでCOPY go.mod go.sum ./を最初に記述し、依存関係を変更しない限りキャッシュを利用します。これによりビルド速度が向上します。
  • 軽量イメージの使用
    実行環境にはAlpineなどの軽量イメージを使用することで、コンテナサイズを最小化します。

サンプルコード

以下の簡単なGoアプリケーションを使用します：

package main

import (
    "fmt"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Hello, Dockerized Go!")
}

func main() {
    http.HandleFunc("/", handler)
    fmt.Println("Server is running on port 8080...")
    http.ListenAndServe(":8080", nil)
}

このコードをDockerでビルドおよび実行することで、環境に依存しないGoアプリケーションが完成します。

トラブルシューティングとベストプラクティス

Dockerを使ってGoアプリケーションをコンテナ化する際には、さまざまな問題が発生することがあります。これらの問題を効果的に解決するためのトラブルシューティング手法と、安定した運用を支えるベストプラクティスを紹介します。

トラブルシューティング

1. ビルドエラー


問題: docker buildでエラーが発生する場合、以下が原因となることがあります。

  • 依存関係の解決失敗
  • go.modやgo.sumが正しく設定されていない場合、go mod downloadが失敗します。

解決策:

  • 必要なモジュールをgo mod tidyで整理し、go mod verifyで整合性をチェックします。
  • go mod editコマンドを使用して、不足している依存パッケージを手動で追加します。

2. 実行エラー


問題: コンテナ内でGoアプリケーションが正しく動作しない場合、以下が考えられます。

  • 実行ファイルがビルドされていない
  • ポートがマッピングされていない

解決策:

  • DockerfileのRUN go build -o main .ステップで、ビルドが正常に完了しているか確認します。
  • コンテナ起動時に正しいポートを指定しているか確認します（例: -p 8080:8080）。

3. 環境の不一致


問題: 開発環境と本番環境で動作が異なる場合、以下が原因となることがあります。

  • ホスト環境の依存関係がコンテナに正しく反映されていない

解決策:

  • 必ずDockerイメージ内でアプリケーションをビルドし、同じイメージを利用します。
  • マルチステージビルドを利用して、依存関係を完全に分離します。

ベストプラクティス

1. Dockerfileの効率的な記述

  • キャッシュの活用: go.modとgo.sumを先にコピーし、依存関係のダウンロードステップをキャッシュ化。
  • マルチステージビルド: ビルドステージと実行ステージを分け、軽量な最終イメージを作成。

2. イメージサイズの最小化

  • 実行環境にはAlpine Linuxなどの軽量イメージを使用し、不要なファイルを除去します。

3. 環境変数の利用

  • 構成をコード内にハードコードせず、環境変数で設定することで柔軟性を向上。
  ENV APP_ENV=production

4. ログとデバッグ

  • コンテナ内でのログを確認するために、docker logsコマンドを活用します：
  docker logs <container_id>

5. 自動化とCI/CD

  • CI/CDパイプラインでDockerイメージのビルド・テストを自動化し、デプロイの一貫性を確保します。

よくある問題とその解決例

問題原因解決策
コンテナ内で実行ファイルが見つからないDockerfileのビルドステップが不足しているRUN go buildステップが正しく設定されているか確認
ポートにアクセスできないポートのマッピング設定が不足しているdocker run -pで正しいポートを指定
ライブラリのバージョンが不一致go.sumが更新されていないgo mod tidyで依存関係を再構築

まとめ


トラブルシューティングとベストプラクティスを組み合わせることで、Dockerを活用したGoアプリケーション開発を効率的に進めることが可能です。環境の一貫性を保ち、エラーを最小限に抑えることで、スムーズな開発・デプロイプロセスを実現できます。

実践例：小規模WebアプリケーションのDocker化

ここでは、具体的な例を使って、小規模なGoのWebアプリケーションをDocker化する方法を説明します。この例を通じて、Goアプリケーションの依存関係管理、ビルド、実行をコンテナ化する流れを実践的に学べます。

アプリケーションの概要


作成するアプリケーションは、簡単なREST APIサーバーです。以下の機能を持ちます：

  • /エンドポイントにアクセスすると、”Hello, Dockerized Go!”と表示する。
  • サードパーティライブラリgithub.com/gorilla/muxを利用。

プロジェクトの構造


以下の構造を作成します：

my-go-app/
├── Dockerfile
├── go.mod
├── go.sum
├── main.go

1. アプリケーションコードの作成

main.goに以下のコードを記述します：

package main

import (
    "fmt"
    "net/http"

    "github.com/gorilla/mux"
)

func main() {
    r := mux.NewRouter()
    r.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Hello, Dockerized Go!")
    })

    fmt.Println("Server is running on port 8080...")
    http.ListenAndServe(":8080", r)
}

2. Goモジュールの初期化

プロジェクトディレクトリで以下を実行してGoモジュールを初期化します：

go mod init my-go-app
go get github.com/gorilla/mux

このコマンドにより、go.modとgo.sumが生成されます。

3. Dockerfileの作成

以下の内容でDockerfileを作成します：

# ビルドステージ
FROM golang:1.20 AS builder

# 作業ディレクトリを作成
WORKDIR /app

# モジュールファイルをコピーして依存関係をダウンロード
COPY go.mod go.sum ./
RUN go mod download

# ソースコードをコピーしてビルド
COPY . .
RUN go build -o main .

# 実行ステージ
FROM alpine:latest
WORKDIR /root/
COPY --from=builder /app/main .

# ポートの設定
EXPOSE 8080

# 実行コマンド
CMD ["./main"]

4. Dockerイメージのビルド

プロジェクトディレクトリで以下を実行します：

docker build -t my-go-app .

5. コンテナの起動

ビルドしたイメージを基にコンテナを起動します：

docker run -it --rm -p 8080:8080 my-go-app
  • -p 8080:8080でホストとコンテナのポートをマッピングします。

ブラウザでhttp://localhost:8080にアクセスすると、”Hello, Dockerized Go!”と表示されます。

6. トラブルシューティング

エラーが発生する場合の確認ポイント

  • ポート設定: DockerfileでEXPOSE 8080が記述されているか確認。
  • 依存パッケージ: go.modにサードパーティパッケージが正しく記載されているか確認。
  • ビルドエラー: docker buildのログを確認して原因を特定。

7. 応用：Docker Composeの利用

複数のサービス（例：データベース）と連携する場合は、docker-composeを使用すると便利です。以下はシンプルなdocker-compose.ymlの例です：

version: '3.8'
services:
  app:
    build:
      context: .
    ports:
      - "8080:8080"

以下のコマンドでアプリケーションを起動します：

docker-compose up

まとめ

この実践例を通じて、GoアプリケーションをDockerでコンテナ化する基本的な手順を学びました。Docker化により、環境の一貫性を確保し、プロジェクトのセットアップとデプロイが効率化されます。この手法は、小規模プロジェクトだけでなく、大規模なシステムにも応用可能です。

まとめ

本記事では、Goプロジェクトの依存関係をDockerで管理する方法について、基本概念から実践例までを解説しました。Goモジュールを活用し、Dockerを組み合わせることで、開発環境と本番環境の一貫性を確保し、依存関係や環境の問題を効率的に解決できます。

また、サードパーティパッケージを含むアプリケーションのDocker化の手順を具体的に示し、トラブルシューティングやベストプラクティスにも触れました。これにより、開発の安定性を向上させるとともに、簡単なデプロイとスケーリングが可能になります。

Dockerを活用することで、Goプロジェクトの効率的な運用と管理が実現できます。ぜひ、この手法をあなたのプロジェクトにも応用してみてください。

Go
Docker 依存関係管理 Go言語

コメント

コメントする

目次
  1. Go言語の依存関係管理の重要性
    1. 依存関係管理の課題
    2. Goモジュールによる依存管理
    3. Dockerを活用した依存管理の強化
  2. Dockerの基礎とGoプロジェクトとの連携
    1. Dockerとは何か
    2. DockerがGoプロジェクトに適している理由
    3. GoプロジェクトでのDockerの利用シーン
  3. 必要なツールと環境構築
    1. 必要なツール
    2. 環境構築の手順
    3. セットアップ完了後の確認
  4. Dockerfileの作成と解説
    1. Dockerfileの構造
    2. 各ステップの解説
    3. このDockerfileの特徴
    4. 実行方法
  5. サードパーティパッケージのインストール方法
    1. パッケージインストールの基本手順
    2. 依存パッケージのテスト
    3. ベストプラクティス
    4. 例：サードパーティパッケージを利用したコード
  6. コンテナ化されたGoアプリケーションのビルド
    1. 1. プロジェクトの準備
    2. 2. Dockerfileの作成
    3. 3. Dockerイメージのビルド
    4. 4. コンテナの起動とテスト
    5. 5. ビルドの最適化ポイント
    6. サンプルコード
  7. トラブルシューティングとベストプラクティス
    1. トラブルシューティング
    2. ベストプラクティス
    3. よくある問題とその解決例
    4. まとめ
  8. 実践例：小規模WebアプリケーションのDocker化
    1. アプリケーションの概要
    2. プロジェクトの構造
    3. 1. アプリケーションコードの作成
    4. 2. Goモジュールの初期化
    5. 3. Dockerfileの作成
    6. 4. Dockerイメージのビルド
    7. 5. コンテナの起動
    8. 6. トラブルシューティング
    9. 7. 応用：Docker Composeの利用
    10. まとめ
  9. まとめ