Dockerとは — コンテナ技術の基本概念とメリット

1. Dockerの概要とコンテナ技術の定義

Dockerは、コンテナ技術を活用したアプリケーションのパッケージ化・実行ツールです。コンテナ技術とは、アプリケーションとその依存関係を「箱」に閉じ込めて、他の環境でも同じように動かせる技術です。この「箱」が「コンテナ」で、Dockerはその箱を作ったり管理したりするための仕組みです。

たとえば、Webアプリケーションを構築する際、開発環境では動くけど、本番環境でエラーが出ることがあります。これは「依存関係の違い」による問題です（例：Node.jsのバージョンが異なるなど）。Dockerはこの問題を解決するために設計されており、「開発環境＝本番環境＝誰のPCでも同じように動く」ことを実現します。

2. コンテナと仮想マシン（VM）の違い

コンテナ技術を理解するには、従来の仮想マシン（VM）との比較が重要です。以下に両者の違いを表にまとめます。

仮想マシンは「OSごと」を起動するため、リソースを多く消費しますが、コンテナはホストOSのカーネルを共有するため、軽量で高速です。この違いを理解することで、Dockerの利点をより深く把握できます。

3. Dockerの主なメリット

Dockerの利用には以下のようなメリットがあります。

① 依存関係の管理が簡単

アプリケーションに必要なライブラリやツールを「Dockerイメージ」に含めれば、環境ごとの設定が不要になります。たとえば、Pythonアプリケーションであれば、以下のようにrequirements.txtを指定して依存関係を自動インストールできます。

# Dockerfileの例
FROM python:3.9
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "app.py"]

② 一貫性のある開発環境

開発者が「Dockerイメージを共有」することで、チーム内の環境差をなくせます。たとえば、以下コマンドでイメージを構築し、同じ環境を再現できます。

# イメージの構築
docker build -t my-app .

# コンテナの起動
docker run -d -p 8000:8000 my-app

③ デプロイの自動化

CI/CD（継続的インテグレーション/継続的デリバリー）と組み合わせて、アプリケーションのデプロイを自動化できます。DockerイメージをDocker Hubなどにプッシュし、本番環境で直接起動すれば、手動の設定ミスを防げます。

4. Dockerの基本コンセプト

Dockerには以下の3つの核心コンセプトがあります。

① イメージ（Image）

アプリケーションとその依存関係を含むテンプレート。例：nginx:latest（最新版のNginxサーバー）。

② コンテナ（Container）

イメージをインスタンス化したもの。実行中のコンテナは、以下コマンドで確認できます。

# 実行中のコンテナ一覧
docker ps

③ Dockerfile

イメージを構築するためのレシピ。例：先ほどのDockerfileはPythonアプリケーションのイメージを構築します。

5. 実践ワーク: あなたの最初のDockerアプリケーション

以下に、Dockerを使って「Hello World」を表示する手順を示します。

ステップ1: Dockerfileの作成

以下の内容をDockerfileに保存します。

# ベースイメージ（Alpine Linuxを用いる）
FROM alpine:latest

# ファイルをコピー
COPY . /app

# 実行コマンド
CMD ["sh", "-c", "echo 'Hello Docker!'"]

ステップ2: イメージの構築

ターミナルで以下を実行します。

docker build -t hello-docker .

ステップ3: コンテナの起動

docker run hello-docker

実行結果:

Hello Docker!

このように、Dockerfileを書くことで、アプリケーションを簡単にパッケージ化できます。

6. 演習課題

以下の課題に取り組んでください。

1. 課題1: 任意のWebアプリケーション（例：Flaskアプリ）をDocker化してみましょう。Dockerfileを作成し、docker runコマンドでブラウザからアクセスできるようにしてください。
2. 課題2: Docker Hubに自分のイメージをアップロードしてみましょう。docker pushコマンドを使用し、他のPCからもイメージを取得できるようにしてください。

まとめと次回の準備

本講では、Dockerの基本概念とメリットを学びました。コンテナ技術はアプリケーションの依存関係を管理し、環境の一貫性を保つ強力なツールです。また、Dockerfileを書くことで、アプリケーションを簡単にパッケージ化できることも確認しました。

次回は「Dockerコマンドの基本操作」を扱い、docker runやdocker buildの詳細な使い方を学びます。準備として、以下のコマンドを実行してDockerが動く環境を整えておきましょう。

# Dockerのバージョン確認
docker --version

参考文献

1. 『Docker — From the Ground Up』（Sven Dowling著）: Dockerの基礎から応用までを丁寧に解説。
2. 『Docker Deep Dive』（Nigel Poulton著）: コンテナ技術の深堀りと実践的な使い方が学べる。
3. Docker公式ドキュメント: https://docs.docker.com/
   DockerのコマンドやAPIの詳細情報が網羅されている。

Dockerのインストール — 環境構築の手順

前回の講義でDockerの基本概念とメリットについて学びました。この第2講では、Dockerを実際の環境にインストールする方法を詳しく説明します。Dockerを活用するためには、まず自分のPCやサーバーにインストールする必要があります。本講義では、Windows、macOS、Linux（Ubuntu）の各OSでDockerをインストールする手順をステップバイステップで解説します。

インストール前の準備

Dockerをインストールする前に、以下の3つのポイントを確認してください：

1. OSの種類とバージョン
   DockerはWindows、macOS、Linuxの各OSで動作しますが、インストール方法が異なります。たとえば、Windowsでは「Docker Desktop」をインストールし、Linuxではコマンドラインでインストールします。

2. 管理者権限の確保
   Dockerをインストールするには、PCやサーバーの管理者権限が必要です。特にLinux環境ではsudoコマンドを使用して管理者として操作します。

3. ネットワーク接続の確認
   Dockerの公式リポジトリやコンテナイメージをダウンロードするため、インターネット接続が必要です。

例:
Windowsの場合、「Windows PowerShell」を開き、管理者として実行します。Linuxの場合、ターミナルでsudoコマンドを使用します。

Windows/macOS向け：Docker Desktopのインストール

WindowsとmacOSでは、Docker公式が提供する「Docker Desktop」を使用してインストールします。これはGUI（グラフィカルユーザーインターフェース）ベースのアプリで、操作が簡単です。

インストール手順

1. Docker公式サイト（https://www.docker.com/products/docker-desktop）にアクセスします。
2. 「Download Docker Desktop」ボタンをクリックして、自分のOSに応じたインストーラーをダウンロードします。
3. ダウンロードしたファイルを実行し、インストーラーの指示に従ってインストールします。

例（コマンドラインでの確認）
インストール後、ターミナルまたはコマンドプロンプトで以下を実行してDockerが正しくインストールされているか確認します：

# Dockerのバージョン確認
docker --version
# 期待される出力例: Docker version 24.0.5, build 357260f

Linux（Ubuntu）向け：コマンドラインでのインストール

Linux環境（特にUbuntu）では、コマンドラインを介してDockerをインストールします。この方法は、サーバー構築や自動化スクリプトに適しています。

インストール手順

1. システムを最新化します： bash sudo apt update && sudo apt upgrade -y
2. Dockerの公式リポジトリを追加します： bash sudo apt install apt-transport-https ca-certificates curl software-properties-common curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
3. Dockerをインストールします： bash sudo apt update sudo apt install docker-ce docker-ce-cli containerd.io

注意点
- apt-transport-httpsはHTTPS経由でのパッケージダウンロードを可能にします。 - gpgコマンドでDockerの署名を検証し、セキュリティを確保します。

インストール後の確認と基本コマンド

インストールが完了したら、以下のコマンドでDockerが正常に動作しているか確認します：

1. Dockerのバージョン確認
   bash docker --version # 出力例: Docker version 24.0.5, build 357260f

2. Dockerデーモンの動作確認
   bash systemctl status docker # 出力例: active (running) が表示されれば成功

3. 簡単なコンテナ実行
   Docker公式が提供するhello-worldイメージを実行してみましょう： bash docker run hello-world # 出力例: "Hello from Docker!" が表示されます

実践ワーク

以下の手順に従って、Docker環境を構築してみましょう：

1. Docker Desktopのインストール（Windows/macOS）
2. Docker公式サイトから最新版をダウンロードし、インストーラーに従ってインストールします。

3. ターミナルでdocker --versionを実行し、バージョンが表示されることを確認します。

4. Ubuntuでのインストール

5. 以下のコマンドを順番に実行し、インストール完了を確認してください： bash sudo apt update sudo apt install docker-ce docker run hello-world

まとめと次回の準備

本講義では、DockerをWindows、macOS、Linux（Ubuntu）にインストールする方法を学びました。インストール後は、docker --versionやdocker run hello-worldなどのコマンドで動作確認を行いました。

次回の準備
次回は「Dockerの基本コマンドとイメージの操作」について学びます。以下の準備を進めておきましょう： - Dockerをインストールし、docker run hello-worldが正常に動作することを確認 - Docker Hub（https://hub.docker.com/）にアクセスして、イメージの検索方法を確認

参考文献

1. Docker公式ドキュメント: https://docs.docker.com/
2. Dockerのインストール手順やコマンドの詳細が記載されています。
3. 『Dockerの教科書』（技術評論社）
4. Dockerの基本から応用まで、日本語で丁寧に解説された書籍。
5. 『Docker徹底入門』（マイナビ出版）
6. 実践的なユースケースを交えて、Dockerの使い方を学べます。

基本コマンド — 実行・停止・一覧表示の操作

前回の講義では、Dockerのインストール手順について学びました。Dockerが環境に正しくインストールされたら、次は実際にコンテナを操作するための基本コマンドをマスターする必要があります。この講義では、コンテナの「実行」「停止」「一覧表示」に焦点を当て、それぞれのコマンドの使い方と具体的な例を通じて、Dockerの操作をスムーズに進められるようになります。初心者向けに、専門用語はできるだけ避け、わかりやすい比喩や実例で説明します。

## コンテナの実行：docker run コマンド

Dockerでコンテナを起動するには、docker run コマンドを使います。このコマンドは、指定したイメージからコンテナを作成し、即座に実行します。イメージとは、コンテナの「設計図」のようなもので、アプリケーションやOSが事前に構成された状態を含んでいます。

基本的な使い方

# イメージ名「nginx」を元にコンテナを起動
docker run nginx

このコマンドは、Docker Hub（Dockerの公式リポジトリ）からnginxイメージを自動的にダウンロードし、コンテナを起動します。nginxはウェブサーバーのソフトウェアで、起動するとすぐにHTTPサービスを提供します。

オプションの活用例

# イメージ名「nginx」を元に、名前「my-nginx」のコンテナを起動
docker run --name my-nginx -d nginx

• --name: コンテナに任意の名前を付けることができます（後で操作しやすくなります）。
• -d: 「detached mode（分離モード）」で実行します。これにより、コンテナはバックグラウンドで動いており、ターミナルを解放できます。

実行中のコンテナの確認

コンテナが起動したかどうかを確認するには、docker ps コマンドを使います（後述）。

## コンテナの停止：docker stop コマンド

コンテナを停止するには、docker stop コマンドを使用します。このコマンドは、指定したコンテナに「停止のシグナル」を送り、正常に終了させます。

基本的な使い方

# コンテナ名「my-nginx」を停止
docker stop my-nginx

このコマンドを実行すると、my-nginxという名前のコンテナが停止します。停止後は、docker ps コマンドで一覧表示しても、そのコンテナは表示されません（ただし、docker ps -a で確認できます）。

タイムアウトの指定

デフォルトでは、docker stop はコンテナに10秒の停止猶予を与えます。タイムアウトを変更するには-tオプションを使います。

# タイムアウトを3秒に設定
docker stop -t 3 my-nginx

## コンテナの一覧表示：docker ps コマンド

現在実行中のコンテナを確認するには、docker ps コマンドを使います。psは「Process Status（プロセスステータス）」の略で、Linuxコマンドと同様の考え方です。

基本的な使い方

# 実行中のコンテナ一覧を表示
docker ps

出力例

CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS          PORTS     NAMES
b7c4f1a4e8d3   nginx     "/docker-entrypoint.…"   5 minutes ago    Up 5 minutes    80/tcp    my-nginx

• CONTAINER ID: コンテナの一意なID。
• IMAGE: どのイメージから作成されたか。
• STATUS: コンテナのステータス（例: Up 5 minutes は5分前から実行中）。
• NAMES: コンテナの名前。

全コンテナの表示（停止中も含む）

# 全コンテナ（停止中も含む）を表示
docker ps -a

## コマンド一覧の整理表

## 実践ワーク

以下を順番に実行して、Dockerコマンドの操作を体験してください。

1. コンテナの起動
   bash docker run --name my-httpd -d httpd

2. httpdはApache HTTP Serverのイメージです。

3. 実行中のコンテナ確認
   bash docker ps

4. my-httpdが一覧に表示されていることを確認します。

5. コンテナの停止
   bash docker stop my-httpd

6. 停止中のコンテナ確認
   bash docker ps -a

7. my-httpdが停止状態にあることを確認します。

## まとめと次回の準備

今回の講義では、Dockerの基本コマンド（docker run、docker stop、docker ps）の使い方を学びました。これらのコマンドは、コンテナの操作の基本であり、今後の学習の基盤になります。次回の講義では、「コンテナの削除」と「イメージの管理」について詳しく説明します。また、docker runのさまざまなオプション（例: ポートマッピング、ボリュームマウント）についても触れていきますので、今回の練習で得たスキルを活かして進めてください。

## 参考文献

1. Docker公式ドキュメント
   https://docs.docker.com/
   Dockerのすべてのコマンドと詳細な使い方が記載されています。

2. 『Docker実践ガイド』（著: 佐藤健太郎）
   Dockerの基本操作から応用まで、具体的な例で学べる書籍です。

3. 『プロフェッショナルDocker』（著: Adrian Mouat）
   Dockerの仕組みと実践的な運用方法を解説した英語書籍。翻訳版もあります。

4. Docker Hub
   https://hub.docker.com/
   イメージの検索やダウンロードが可能な公式リポジトリ。nginxやhttpdなどのイメージが公開されています。

Dockerfileの作成 — イメージ構築の仕組み

前回の講義では、Dockerの基本コマンド（docker run、docker ps、docker stopなど）を通じてコンテナの実行・管理を行いました。今回は、コンテナを構成するベースとなる「イメージ」を自分で作成する方法に焦点を当てます。Dockerでは、この「イメージ」を作成するための仕組みとして、Dockerfileという特殊なファイルを使用します。本講義では、Dockerfileの構文と実践的な書き方を学ぶことで、アプリケーション固有の環境を再現するスキルを習得します。

Dockerfileとは？イメージ構築の設計図

Dockerfileは、Dockerイメージを構築するための指示書です。このファイルに書かれたコマンド（指令）を順に実行することで、ベースイメージからカスタムしたアプリケーション用のイメージが作成されます。たとえば、Webアプリケーションを動かすには「Node.jsがインストールされた環境」が必要ですが、Dockerfileを使ってその環境を自動で構築できます。

なぜDockerfileが必要か？

• 一貫性の確保：開発環境・テスト環境・本番環境で同じイメージが作成される。
• 再現性の向上：誰でも同じ手順で同じイメージが作成できる。
• 依存管理：アプリケーションに必要なライブラリや設定を一元管理。

Dockerfileの基本構文と例

Dockerfileは、一連の命令（指令）で構成されます。代表的な指令とその使い方を以下に示します。

代表的なDockerfileの指令

実際のDockerfile例（Node.jsアプリケーション向け）

# ベースイメージを指定（Node.js 18）
FROM node:18

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

# ローカルのファイルをコピー
COPY package*.json ./
COPY . .

# 依存関係をインストール
RUN npm install

# デフォルトコマンドを指定
CMD ["npm", "start"]

この例では、FROMでNode.jsの環境をベースにし、WORKDIRでアプリケーションのディレクトリを設定。COPYでローカルのファイルをコピーし、RUNでnpm installを実行して依存関係をインストールします。最後にCMDでアプリケーションの起動コマンドを指定しています。

Dockerfileの最適化テクニック

Dockerfileを書く際には、イメージのサイズを小さくし、構築時間を短縮することを目指すのがベストプラクティスです。以下に具体的な方法を紹介します。

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

• 軽量なイメージを使う：alpine系のベースイメージはサイズが小さい。
• 例：FROM node:18-alpine（Node.jsのアルパイン版）

2. 多段ビルド（Multi-Stage Build）

• 不要な中間ファイルを削除：コンパイル用のツールを最終イメージには含めない。
• 例：Go言語アプリケーションの場合

# 1. コンパイル用のステージ
FROM golang:1.20 as builder
WORKDIR /app
COPY . .
RUN go build -o /go/bin/app

# 2. 最終イメージ（軽量なアルパイン）
FROM alpine:latest
COPY --from=builder /go/bin/app /app
CMD ["/app"]

この例では、golangイメージでアプリケーションをコンパイルし、最終的にalpineイメージにコピーすることで、最終イメージのサイズを削減しています。

3. 層（Layer）の最適化

• 変更が少ない手順を上に配置：キャッシュを効かせ、再ビルドの時間を短縮。
• 例：package.jsonを先にコピーしてnpm installを実行し、その後アプリコードをコピー。

実践ワーク: シンプルなWebアプリケーションのDocker化

以下のように、Node.jsで書かれた簡単なWebアプリケーションをDocker化してみましょう。

1. アプリケーションコードの準備

プロジェクトディレクトリに以下のファイルを作成します。

// app.js
const express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.send('Hello from Docker!');
});

app.listen(3000, () => {
  console.log('Server is running on port 3000');
});

// package.json
{
  "name": "docker-demo",
  "version": "1.0.0",
  "dependencies": {
    "express": "^4.18.2"
  },
  "scripts": {
    "start": "node app.js"
  }
}

2. Dockerfileの作成

プロジェクトディレクトリに以下のDockerfileを配置します。

# ベースイメージ
FROM node:18-alpine

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

# ローカルファイルをコピー
COPY package*.json ./
COPY . .

# 依存関係のインストール
RUN npm install

# デフォルトコマンド
CMD ["npm", "start"]

3. イメージの構築と実行

ターミナルで以下のコマンドを実行します。

# イメージの構築
docker build -t docker-demo .

# コンテナの実行（ポート3000をホストの3000にマッピング）
docker run -d -p 3000:3000 docker-demo

# アクセス確認
curl http://localhost:3000

まとめと次回の準備

本講義では、Dockerfileの基本構文と最適化テクニックを学び、実際のアプリケーションをDocker化するワークをしました。Dockerfileを作成する際には、以下のポイントを意識することが重要です。

• ベースイメージの選定
• 層の最適化によるビルド効率化
• 多段ビルドによる最終イメージの軽量化

次回の講義では、「Docker Composeによる複数コンテナの管理」について学びます。複数のサービス（例: Webアプリケーションとデータベース）を連携させる方法を解説します。

参考文献

1. Docker公式ドキュメント: https://docs.docker.com/
2. 『Docker入門』 by 河原 隆一（技術評論社）
3. Dockerの基礎から応用までを丁寧に解説。
4. 『Dockerの極意』 by Adrian Mouat（O'Reilly Japan）
5. プロフェッショナル向けの実践的なTipsが満載。
6. 『Docker Practitioner's Guide』 by Sander van Vugt（Packt Publishing）
7. システム管理者・開発者向けの詳細なガイド。

イメージのビルド — Dockerfileの実行と最適化

前回の講義では、Dockerfileの作成方法について学びました。今回は、作成したDockerfileを使ってイメージをビルド（作成）する方法と、その過程で重要な最適化のポイントについて詳しく解説します。Dockerの本質的な価値を引き出すには、効率的なイメージ構築が不可欠です。

Docker buildコマンドの基本構文

Dockerfileからイメージをビルドするには、docker buildコマンドを使用します。基本的な構文は以下の通りです：

docker build -t イメージ名:タグ .

• -tオプションはタグ（tag）を指定するもので、イメージの識別に使用されます。
• .は、Dockerfileが存在するコンテキスト（作業ディレクトリ）を指定します。

実行例：シンプルなNode.jsアプリケーションのビルド

以下のようなDockerfileがある場合：

# Dockerfile
FROM node:18
WORKDIR /app
COPY . .
RUN npm install
CMD ["node", "app.js"]

コマンドは以下のように実行します：

docker build -t my-node-app:1.0 .

このコマンドにより、node:18ベースイメージから、アプリケーションがインストールされ、実行用のイメージが作成されます。

ビルドプロセスのステップとキャッシュの活用

Dockerはビルド時にキャッシュを活用し、効率化を図ります。各RUN、COPY、ADDコマンドごとにキャッシュがチェックされ、変更がなければスキップされます。

キャッシュの挙動例

FROM ubuntu:22.04
RUN apt-get update && apt-get install -y curl
COPY . /app
RUN cd /app && ./build.sh

• 最初のビルドでは、すべてのステップが実行されます。
• 2回目以降、apt-get install以降のコマンドが変更されていなければ、キャッシュが使用されます。

注意点：COPYやRUNコマンドを変更すると、キャッシュが無効化されます。この特性を活かして、変更頻度の高いステップを後ろに配置することで、再ビルド時間を短縮できます。

イメージの最適化：サイズとパフォーマンス

Dockerイメージのサイズは、特にクラウド環境やネットワーク転送において重要です。以下に最適化のポイントを整理します。

実践例：マルチステージビルド

以下は、Go言語アプリケーションをビルドするマルチステージの例です：

# 1. ビルド用ステージ
FROM golang:1.20 as builder
WORKDIR /app
COPY . .
RUN go build -o /app/my-go-app

# 2. 実行用ステージ（alpineベースで軽量）
FROM alpine:3.18
WORKDIR /root/
COPY --from=builder /app/my-go-app .
CMD ["./my-go-app"]

• builderステップでは開発ツールが含まれるが、最終的にalpineベースの軽量イメージが作成されます。

.dockerignoreファイルの活用

Dockerfileと同じディレクトリに.dockerignoreファイルを配置することで、COPYやADDコマンドでコンテキストに含めたくないファイルを指定できます。これにより、不要なファイルがイメージに含まれるのを防ぎ、セキュリティとパフォーマンスを向上させます。

.dockerignoreの例

node_modules/
.git
*.log
.env

この設定では、node_modulesディレクトリや.envファイルがビルドコンテキストに含まれません。

実践ワーク：イメージの最適化を試してみよう

以下のステップに従って、Node.jsアプリケーションのイメージを最適化してください：

1. Dockerfileの作成： ```Dockerfile FROM node:18 as builder WORKDIR /app COPY package*.json ./ RUN npm install COPY . . RUN npm run build

FROM nginx:alpine COPY --from=builder /app/build /usr/share/nginx/html EXPOSE 80 CMD ["nginx", "-g", "daemon off;"] ```

1. .dockerignoreの作成： node_modules/ .git *.env

2. ビルドコマンドの実行： bash docker build -t optimized-node-app .

3. イメージサイズの確認： bash docker images optimized-node-app

まとめと次回の準備

今回の講義では、Dockerfileの実行方法と、イメージの最適化技術を学びました。特にマルチステージビルドやキャッシュの活用は、効率的な開発環境構築に不可欠です。次回は、複数コンテナの連携を実現するDocker Composeについて解説します。準備として、docker-compose.ymlファイルの基本構文について触れておきましょう。

参考文献

1. 公式ドキュメント: Docker Build Guide
2. 書籍: 『Dockerによるアプリケーション開発入門』（O'Reilly Japan）
3. 書籍: 『DockerとKubernetesによるクラウドネイティブ開発』（技術評論社）
4. ブログ記事: Best Practices for Writing Dockerfiles

コンテナの起動管理 — ポートマッピングとバックグラウンド実行

前回の講義では、Dockerfileの作成やイメージのビルド方法を学びました。今回は、コンテナを実際の環境で動かすための重要な技術「ポートマッピング」と「バックグラウンド実行」について説明します。これらは、ローカル環境や本番環境でアプリケーションを構築する際に必須の知識です。

ポートマッピングの基本

コンテナは、ネットワークの観点から「完全に閉じた環境」として動作します。つまり、コンテナ内のアプリケーションが80番ポートでHTTPを提供している場合、ホストマシン（あなたのPCやサーバー）の80番ポートとは物理的に別物です。これを「ポートマッピング」を使って結びつける必要があります。

なぜ必要か？

たとえば、ローカルで開発中のウェブアプリケーション（ポート8080）をブラウザで確認する場合、コンテナ内とホストのポートをマッピングしないとアクセスできません。Dockerはデフォルトでネットワークを分離するため、手動で設定が必要です。

実装方法

docker run コマンドに -p オプションを使います。形式は ホストポート:コンテナポート です。

# ホストの8080ポートをコンテナの80ポートにマッピング
docker run -d -p 8080:80 nginx

• -d: バックグラウンド実行（後述）
• -p 8080:80: ポートマッピング
• nginx: 使用するイメージ

このコマンドで、localhost:8080 にアクセスすると、Nginxのウェブサーバーが起動します。

バックグラウンド実行の仕組み

コンテナを「フォアグラウンド」で実行すると、ターミナルがそのプロセスに占有され、他の作業ができません。これに対して「バックグラウンド実行」では、コンテナを別プロセスとして起動し、ターミナルを解放します。

実装方法

-d オプションを指定します。

# バックグラウンドでコンテナを起動
docker run -d -p 8080:80 nginx

• -d: detached mode（分離モード）で起動
• docker ps コマンドで動作中のコンテナを確認できます。

フォアグラウンド vs バックグラウンド

ポートマッピングとバックグラウンドの併用

多くの場合、両方のオプションを同時に使用します。たとえば、ウェブアプリケーションをローカルで開発する場合、以下のようにします。

サンプルコード（Python Flaskアプリ）

1. Dockerfileの作成

# Dockerfile
FROM python:3.9
WORKDIR /app
COPY . .
RUN pip install -r requirements.txt
EXPOSE 5000
CMD ["python", "app.py"]

1. イメージのビルド

docker build -t my-flask-app .

1. 実行コマンド

docker run -d -p 5000:5000 my-flask-app

• EXPOSE 5000: Dockerfileでポートを宣言（実行時必須ではないが推奨）
• -d -p: バックグラウンドとポートマッピングの併用

このアプリは、http://localhost:5000 からアクセスできます。

トラブルシューティング

ポートマッピングの失敗

• 原因1: ホストのポートが既に使用中
  docker run が失敗する場合、docker ps -a で他のコンテナを確認し、docker stop で終了させましょう。

• 原因2: コンテナ内ポートが未開放
  Dockerfileで EXPOSE していない場合、docker run はエラーにならず、アクセス不可になります。

バックグラウンド実行の確認

• コマンド: docker logs [コンテナID]
  実行中のコンテナのログを確認できます。

docker logs my-container

実践ワーク

タスク: シンプルなウェブサーバーを作成

1. 以下のコードを app.py に保存

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello():
    return "Hello from Docker!"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

1. requirements.txt を作成

flask

1. Dockerfileを作成し、イメージをビルド
2. docker run -d -p 5000:5000 my-flask-app で起動
3. ブラウザで http://localhost:5000 にアクセス

まとめと次回の準備

• ポートマッピングは、ホストとコンテナのネットワークを結びつけるために必要です。
• バックグラウンド実行でターミナルを解放し、複数のコンテナを同時に管理できます。
• 両方を組み合わせて、実際のアプリケーションを構築できるようになりましょう。

次回は、「コンテナ間の通信とネットワーク構成」について学びます。Dockerネットワークの基本と、複数コンテナの連携方法を解説します。

参考文献

1. Docker公式ドキュメント - ポートマッピングやバックグラウンド実行の公式解説
2. 『Docker — From the Ground Up』 by Sven Dowling - Dockerの基本概念と実践
3. 『Dockerで学ぶシステム開発入門』 by 田中 修一 - 日本語でのDocker実践ガイド（特にネットワーク編）

ネットワーク設定 — コンテナ間通信の実装

前回の講義では、コンテナの起動管理やポートマッピングについて学びました。この第7講では、コンテナ間の通信を実現するためのネットワーク設定について詳しく解説します。Dockerのコンテナ技術では、ネットワークの設定がアプリケーションの連携やサービスの構築に不可欠です。この講義では、ネットワークの基本概念から実践的な設定方法までを初心者にもわかりやすく説明します。

コンテナ間通信とは何か

コンテナ間通信とは、複数のコンテナがネットワークを通じてデータをやり取りすることを指します。たとえば、WebアプリケーションがMySQLデータベースに接続する場合、それぞれが別のコンテナとして動作している場合でも、ネットワークを介して通信を行う必要があります。

Dockerでは、デフォルトでbridgeネットワークが提供されていますが、カスタムネットワークを構築することで、より柔軟な通信が可能になります。このセクションでは、Dockerのネットワークの種類と役割について説明します。

Dockerネットワークの種類

Dockerは以下の3種類のネットワークをサポートしています：

実例：bridgeネットワークの確認

# Dockerのデフォルトbridgeネットワークを確認
docker network ls

このコマンドを実行すると、bridgeネットワークがリストアップされます。このネットワークに接続されたコンテナは、IPアドレスを自動的に割り当てられ、他のコンテナと通信できます。

カスタムネットワークの作成

カスタムネットワークを作成することで、特定のコンテナグループ間での通信を効率化できます。たとえば、my-networkというネットワークを作成し、Webアプリケーションとデータベースのコンテナをそこに接続することで、より安全な通信が可能になります。

実例：カスタムネットワークの作成と接続

# カスタムネットワークの作成
docker network create my-network

# コンテナをカスタムネットワークに接続
docker run -d --name web-app --network my-network nginx
docker run -d --name db --network my-network mysql

この例では、web-appとdbという2つのコンテナが同じネットワークに接続されています。これにより、web-appコンテナはdbコンテナにdbというホスト名でアクセスできます。

ホスト名による通信の実現

Dockerでは、同じネットワークに接続されたコンテナは、ホスト名で相互にアクセスできます。これは、DNS（ドメインネームシステム）の仕組みを利用しており、コンテナの名前をIPアドレスに自動的に変換します。

実例：ホスト名を使用した通信

# web-appコンテナ内でcurlコマンドを使用
docker exec -it web-app curl http://db

このコマンドは、web-appコンテナからdbコンテナにHTTPリクエストを送信します。DockerのDNSがdbというホスト名をIPアドレスに解決し、通信が可能になります。

高度な設定：コンテナのリンク

Dockerでは、--linkオプションを使用してコンテナ同士を直接リンクさせることもできます。ただし、この方法は古い仕様であり、カスタムネットワークの使用が推奨されています。

実例：--linkオプションの使用

# dbコンテナを起動
docker run -d --name db mysql

# web-appコンテナをdbにリンク
docker run -d --name web-app --link db nginx

この例では、web-appコンテナがdbコンテナにリンクされ、dbコンテナのホスト名でアクセスできます。ただし、--linkはカスタムネットワークと併用する必要があるため、最新のプロジェクトでは避けてください。

実践ワーク：2つのコンテナ間の通信を構築

演習課題

以下を手順に従って、2つのコンテナ間の通信を実装してください：

1. カスタムネットワークの作成
   名前はmy-networkとします。

2. Nginxコンテナの起動
   名前はweb-server、ネットワークはmy-network。

3. MySQLコンテナの起動
   名前はdb-server、ネットワークはmy-network。

4. 通信の確認
   web-serverコンテナからdb-serverコンテナにcurlコマンドを送信し、応答を確認してください。

解答例

# 1. カスタムネットワークの作成
docker network create my-network

# 2. Nginxコンテナの起動
docker run -d --name web-server --network my-network nginx

# 3. MySQLコンテナの起動
docker run -d --name db-server --network my-network mysql

# 4. 通信の確認
docker exec -it web-server curl http://db-server

この演習では、カスタムネットワークを介して2つのコンテナが通信できることを確認できます。

まとめと次回の準備

本講義では、Dockerのネットワーク設定について以下を学びました： - コンテナ間通信の基本概念 - Dockerネットワークの種類と特徴 - カスタムネットワークの作成と使用 - ホスト名による通信の実現方法 - 実践的な演習を通じた理解の深め方

次回の講義では、Docker Composeの使用について学び、複数コンテナの管理をより効率化する方法を紹介します。ぜひ、本日の演習で構築したネットワークを活用して、Docker Composeの準備を進めてください。

参考文献

1. Docker公式ドキュメント
   https://docs.docker.com/network/
   Dockerのネットワーク設定に関する詳細な情報が掲載されています。

2. 『Dockerによるアプリケーション開発入門』（著：Adrian Mouat）
   Dockerの基本からネットワーク、コンテナ管理までをわかりやすく解説した書籍。

3. 『Dockerネットワーク完全ガイド』（著：Kevan Davis）
   ネットワーク設定の高度なトピックを扱った専門書。

4. 『Docker – From Zero to Production』（著：James Turnbull）
   プロダクション環境でのDockerの運用方法を網羅した書籍。ネットワーク構成の実例も多数掲載。

ボリュームの活用 — データ永続化と共有

前回の講義では、コンテナ間でのネットワーク通信の実装方法を学びました。コンテナがネットワークを通じて連携できるようになった今、次に重要なのは「データの扱い」です。Dockerのコンテナは一時的な性質を持っていますが、アプリケーションが扱うデータ（例: データベースの内容やアップロードされたファイル）は永続的に保存したい場合があります。この課題を解決するのがボリューム（Volume）という機能です。本講義では、ボリュームの基本概念から実践的な使い方までをわかりやすく解説します。

1. ボリュームとは？ — データ永続化のための仕組み

Dockerコンテナは起動時に一時的なファイルシステムを持つため、コンテナが停止・削除されると中に保存されていたデータも消えてしまいます。これはアプリケーション開発やテストには便利ですが、本番環境では問題です。例えば、ウェブアプリがユーザーのアップロードデータを保存する場合、コンテナが再起動してもデータが残るようにする必要があります。

ボリュームはこの課題を解決するための仕組みです。ボリュームとは、ホストマシン（Dockerを実行しているPCやサーバー）上の特別なディレクトリで、コンテナと共有できる永続的なストレージ領域です。以下のような特徴があります：

• コンテナのライフサイクル（起動/停止/削除）に影響されない
• 複数コンテナで同時にアクセス可能
• バックアップや移行が容易
• Dockerが自動で管理するため、手動でディレクトリを作成する必要がない

2. ボリュームの作成と管理

ボリュームの操作はdocker volumeコマンドで行います。以下に基本的な操作を示します：

2-1. ボリュームの作成

# ボリューム名「my-volume」を作成
docker volume create my-volume

2-2. 作成済みボリュームの確認

docker volume ls

2-3. ボリュームの詳細情報表示

docker volume inspect my-volume

2-4. ボリュームの削除

docker volume rm my-volume

3. ボリュームの実際の使い方 — データベースの例

以下では、MySQLコンテナにボリュームをマウントしてデータを永続化する例を示します。

3-1. ボリューム付きでMySQLコンテナを起動

docker run -d \
  --name mysql-container \
  -e MYSQL_ROOT_PASSWORD=secret \
  -v my-volume:/var/lib/mysql \
  mysql:latest

• -v my-volume:/var/lib/mysql：ボリュームmy-volumeをMySQLのデータ保存先ディレクトリにマウント
• -d：バックグラウンドで実行

3-2. データを保存

# データベースに接続してテーブルを作成
docker exec -it mysql-container mysql -u root -psecret -e "CREATE DATABASE test_db;"

3-3. コンテナを削除してもデータを保持

docker stop mysql-container
docker rm mysql-container

3-4. 新しいコンテナで同じボリュームを再利用

docker run -d \
  --name new-mysql-container \
  -e MYSQL_ROOT_PASSWORD=secret \
  -v my-volume:/var/lib/mysql \
  mysql:latest

このように、ボリュームに保存されたデータはコンテナが削除されても残ります。

4. ボリュームとバインドマウントの違い

ボリュームと似た機能にバインドマウント（Bind Mount）があります。両者の違いを整理します：

5. 複数コンテナ間でのデータ共有

ボリュームは複数コンテナで同時にアクセスできます。例えば、ウェブアプリとデータベースが共通のボリュームを使うケースです。

5-1. 共有ボリュームを作成

docker volume create shared-data

5-2. データベースコンテナを起動

docker run -d \
  --name db-container \
  -v shared-data:/data \
  some-database-image

5-3. ウェブアプリコンテナを起動

docker run -d \
  --name web-container \
  -v shared-data:/data \
  some-web-app-image

これにより、/dataディレクトリに保存されたデータは両方のコンテナで共有されます。

6. ボリュームのバックアップと復元

ボリュームのデータをバックアップするには、専用のコンテナを作成してtarコマンドを使用します。

6-1. バックアップ用コンテナを起動

docker run --rm \
  --name backup-container \
  -v my-volume:/volume \
  -v $(pwd):/backup \
  alpine \
  tar cvf /backup/backup.tar -C /volume .

• alpine：軽量なLinuxイメージ

6-2. バックアップファイルを復元

docker run --rm \
  --name restore-container \
  -v my-volume:/volume \
  -v $(pwd):/backup \
  alpine \
  tar xvf /backup/backup.tar -C /volume

7. ボリュームのベストプラクティス

• 永続化が必要なデータは必ずボリュームに保存する（例: データベース、ログファイル）
• バインドマウントは設定ファイルの共有に限る（例: nginx.confの編集）
• ボリューム名を意味のある名前にする（例: mysql-dataではなくproduction-mysql-data）
• 不要なボリュームを定期的に削除する（docker volume pruneコマンド）

実践ワーク

以下を順番に実行して、ボリュームの動作を確認してください：

1. ボリュームmy-test-volumeを作成
2. alpineコンテナを起動し、ボリュームを/dataにマウント
3. ファイルを作成（例: echo "Hello Volume" > /data/test.txt）
4. コンテナを停止・削除
5. 新しいコンテナで同じボリュームをマウントし、test.txtの中身を確認

まとめと次回の準備

本講義では、ボリュームの基本操作から実践的な使い方までを学びました。ボリュームはデータ永続化と共有のための必須機能であり、特に複数コンテナの連携や本番環境での運用に不可欠です。次回は、Docker Composeの導入と複数コンテナの管理方法について解説します。事前にdocker-compose.ymlの構文に触れておくとスムーズです。

参考文献

1. Docker公式ドキュメント: https://docs.docker.com/storage/volumes/
2. 書籍『Docker — From DevOps to Production』（O'Reilly Media）
3. DigitalOceanのチュートリアル: https://www.digitalocean.com/community/tutorials/docker-volume-tutorial

Docker Compose入門 — 複数コンテナの連携

これまでの講義で、Dockerの基本的な使い方（ポートマッピング、ネットワーク設定、ボリュームの活用）を学んできました。しかし、実際の開発や運用では「複数のコンテナを連携させながら管理する」必要があります。例えば、ウェブアプリケーションとデータベースを同時に起動させる場合などです。このような複数コンテナの管理を効率化するためのツールが Docker Compose です。この講義では、Docker Composeの基本構文から実践的な使い方までをわかりやすく解説します。

Docker Composeとは何か？

Docker Composeは、複数のコンテナを1つの設定ファイルで管理するためのツールです。設定ファイル（docker-compose.yml）にサービス（コンテナ）の構成や依存関係を記述することで、複雑な環境を一括で起動・停止できます。

なぜDocker Composeが必要なのか？

• 手動で複数コマンドを入力する手間を省ける
  例えば、docker runコマンドを3回入力する代わりに、docker-compose upだけで完了。
• 環境構成の再現性が高まる
  設定ファイルがあれば、誰でも同じ環境を簡単に構築可能。
• サービス間の依存関係を管理できる
  「Aコンテナが起動してからBコンテナを起動する」といった条件を自動化。

docker-compose.ymlの基本構造

Docker Composeでは、YAML形式の設定ファイル（docker-compose.yml）を作成します。以下は最も基本的な構文です。

version: '3'  # Composeのバージョン
services:
  webapp:
    image: nginx:latest  # 使用するイメージ
    ports:
      - "80:80"  # ホストの80ポートとコンテナの80ポートをマッピング

キーワードの説明

• version: Composeの仕様バージョン（3.xが一般的）。
• services: コンテナを定義するセクション。
• image: 使用するDockerイメージを指定。
• ports: ポートマッピングを設定（ホスト:コンテナ）。

サービス、ネットワーク、ボリュームの定義

複数コンテナを連携させるには、サービス間のネットワークやボリュームを統一して管理します。

version: '3'
services:
  web:
    image: nginx
    ports:
      - "80:80"
    networks:
      - app-network  # 自作のネットワークに接続
    volumes:
      - ./data:/usr/share/nginx/html  # ローカルディレクトリをマウント

  db:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: secret  # 環境変数を設定
    networks:
      - app-network
    volumes:
      - db-data:/var/lib/mysql  # ボリューム名を指定

volumes:
  db-data:  # Composeで自動作成されるボリューム

networks:
  app-network:  # 自作のネットワークを定義

設定のポイント

• ネットワーク（networks）
  同じネットワークに所属するサービスは、お互いにサービス名でアクセス可能（例：webコンテナからhttp://dbでMySQLに接続）。
• ボリューム（volumes）
  データ永続化や共有に使用。db-dataのような名前付きボリュームは、Composeが自動で管理。

サービスの連携と環境変数の活用

複数コンテナ間で通信する際、環境変数を活用することで柔軟な設定が可能です。

サンプル設定

version: '3'
services:
  app:
    image: node:14
    command: node server.js
    environment:
      DB_HOST: db  # dbサービスのホスト名
      DB_PORT: 3306
    ports:
      - "3000:3000"
    depends_on:
      - db  # dbが起動してからappを起動

  db:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: rootpass

環境変数の利点

• 設定の柔軟性
  DBのホスト名やポートをコードにハードコーディングせず、外部から変更可能。
• 依存関係の明確化
  depends_onでサービスの起動順序を指定（例：DBが先に起動）。

実践ワーク：ウェブアプリ＋データベースの構築

以下は、Node.jsアプリケーションとMySQLデータベースを連携させる例です。

ステップ1: ファイル構成

myapp/
├── docker-compose.yml
├── app/
│   └── server.js  # Node.jsアプリ
└── data/          # DBの永続化先

ステップ2: docker-compose.ymlの記述

version: '3'
services:
  app:
    build: ./app  # Dockerfileがあるディレクトリ
    ports:
      - "3000:3000"
    environment:
      DB_HOST: db
      DB_USER: root
      DB_PASSWORD: rootpass
    depends_on:
      - db

  db:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: rootpass
    volumes:
      - ./data:/var/lib/mysql

ステップ3: Dockerfileの例（Node.jsアプリ）

FROM node:14
WORKDIR /app
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]

実行コマンド

# すべてのサービスを起動
docker-compose up -d

# ログを確認
docker-compose logs -f

# サービスを停止
docker-compose down

演習課題

課題1: 以下の要件に沿ってdocker-compose.ymlを作成し、動作確認を行ってください。
- サービス1: nginxコンテナ（ポート80を公開）
- サービス2: redisコンテナ（ネットワークを共有）
- ボリューム: redis-dataを定義し、Redisのデータを永続化

課題2: 課題1の環境で、NginxコンテナがRedisにアクセスするスクリプトを実装してください。
（ヒント：Nginxコンテナ内でredis-cliをインストールし、redisサービスに接続）

まとめと次回の準備

今回の講義で学んだポイントを整理します： | 概念 | 内容 | |------|------| | Docker Compose | 複数コンテナの連携を簡潔に管理するためのツール | | docker-compose.yml | サービス、ネットワーク、ボリュームの定義ファイル | | ネットワーク | 同一ネットワーク内のサービスは相互にアクセス可能 | | ボリューム | データの永続化や共有に使用（名前付きボリュームが便利） |

次回の準備
次回は「Docker Composeの高度な使い方 — ビルド自動化と環境変数管理」をテーマに、Docker Composeの実践的な応用テクニックを学びます。以下の準備を済ませておいてください： - docker-compose buildコマンドの動作を確認 - .envファイルを使った環境変数の設定を試してみる

参考文献

1. 公式ドキュメント
2. Docker Compose Documentation
3. 書籍
4. 『Dockerで始めるアプリ開発』（技術評論社）
5. 『Docker Compose徹底入門』（SBクリエイティブ）
6. 技術ブログ
7. Docker Composeによる複数コンテナの構築（Qiita）

実践プロジェクト — Webアプリケーションのコンテナ化

これまでの講義で学んだネットワーク設定やボリュームの活用、Docker Composeの基本を活かし、今ではいよいよ実際のWebアプリケーションをコンテナ化してみましょう。この講義では、FlaskをベースとしたシンプルなWebアプリケーションをDockerで構築し、データベースとの連携まで実現します。このプロジェクトを通じて、Dockerの実践的な使い方と、開発環境の標準化の価値を体験してください。

1. プロジェクト概要と目標

本プロジェクトでは以下のステップを実行します： 1. Webアプリケーションのコード作成（Flask使用） 2. Dockerfileの作成とコンテナのビルド 3. Docker Composeでデータベースとの連携構築 4. 実行環境のテストと確認

最終的には、1つのコマンドでアプリケーションとデータベースを起動できる環境を作成します。この実践では、Docker Composeのdocker-compose.ymlファイルを活用し、複数コンテナの連携を実現します。

実行環境の構成イメージ

2. Dockerfileの作成

Dockerfileはコンテナの作成手順書です。以下はFlaskアプリケーションのDockerfile例です：

# 基本イメージを指定（Python 3.9の軽量版）
FROM python:3.9-slim

# ワークディレクトリの作成
WORKDIR /app

# 依存関係のコピーとインストール
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# アプリケーションコードのコピー
COPY . .

# 実行コマンドの指定（gunicornでアプリケーションを起動）
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app"]

Dockerfileのポイント解説

• FROM: 基本となるイメージを指定（ここではPython環境）
• WORKDIR: コンテナ内での作業ディレクトリを設定
• COPY: ホストマシンのファイルをコンテナ内にコピー
• RUN: コンテナ内でコマンドを実行（依存ライブラリのインストール）
• CMD: コンテナ起動時に実行されるコマンド

このDockerfileにより、アプリケーションの依存関係がすべて解決され、gunicornサーバーでアプリケーションが起動します。requirements.txtにはFlaskやgunicornなど必要なライブラリを記述します。

3. Docker Composeの設定

複数のコンテナを連携させるには、Docker Composeが非常に便利です。以下はdocker-compose.ymlの例です：

version: '3.8'

services:
  web:
    build: .
    ports:
      - "5000:5000"
    volumes:
      - .:/app
    depends_on:
      - db

  db:
    image: postgres:13
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: mydb
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

Docker Composeの構成要素

• services: 実行するサービス（webアプリケーションとPostgreSQL）
• build: webサービスではカレントディレクトリのDockerfileをビルド
• ports: ホストとコンテナのポートをマッピング（例：5000番ポートの公開）
• volumes: コードの変更を反映するためのマウントや、データベースのデータ永続化
• depends_on: webサービスはdbサービスの起動を待つ

この設定により、docker-compose upコマンドでアプリケーションとデータベースが同時に起動します。volumesの設定により、コード変更を反映する際はコンテナを再ビルドする必要がありません。

4. アプリケーションの実行と確認

以下のようにコマンドを実行してください：

# コンテナのビルドと起動
docker-compose up --build

# 別ターミナルでログの確認
docker-compose logs -f web

アプリケーションが正常に起動した場合、ブラウザでhttp://localhost:5000にアクセスすると、Flaskアプリケーションが動作していることが確認できます。データベース接続の確認には、PostgreSQLクライアントを使用して接続テストを行いましょう：

# PostgreSQLに接続
docker-compose exec db psql -U user -d mydb

# テーブル作成の例
CREATE TABLE test (id SERIAL PRIMARY KEY, name VARCHAR(100));

5. 実践ワーク

以下の課題に取り組んでください： 1. アプリケーションのカスタマイズ: app.pyを編集し、Hello, World!を自分の名前に変更してみましょう。 2. ポート変更: docker-compose.ymlでWebアプリケーションのポートを8080に変更し、再起動して確認してください。 3. 環境変数の追加: PostgreSQLのユーザー名やパスワードを環境変数で管理できるように、.envファイルを追加してみましょう。

まとめと次回の準備

本講義では、Dockerfileの作成方法やDocker Composeによる複数コンテナの連携を学び、Webアプリケーションのコンテナ化プロジェクトを完成させました。このようにして、開発環境の標準化やデータベースとの連携が簡単に実現できるDockerの強みを体感していただけたと思います。

次回は、このプロジェクトを拡張し、Docker Hubへのイメージの公開とCI/CD（継続的インテグレーション/継続的デリバリー）の導入について学びます。準備として、GitHubアカウントの作成とDocker Hubのアカウント登録を事前に済ませておいてください。

参考文献

1. 『Dockerによるアプリケーション開発と運用の新常識』（技術評論社）
2. Dockerの実践的な使い方を網羅した入門書
3. Docker公式ドキュメント: https://docs.docker.com/
4. Docker Composeやネットワーク設定の詳細情報
5. 『PythonによるWebアプリケーション開発』（SBクリエイティブ）
6. Flaskやgunicornの使い方を学ぶための参考書

この講義では、Dockerの基本構文から実際のプロジェクトへの応用までを段階的に学ぶことで、初心者でも安心してDockerの実践力を身につけることができます。コンテナ技術の理解を深め、開発ワークフローの効率化を目指しましょう！