MENU
  1. ホーム
  2. Rust
  3. Dockerでデータベース環境をセットアップしRustと連携する方法

Dockerでデータベース環境をセットアップしRustと連携する方法

Rust

Rustはその高いパフォーマンスと安全性から、バックエンド開発やシステムプログラミングで人気が高まっています。しかし、データベースを利用するアプリケーションを開発する際、環境の構築や依存関係の管理は煩雑になりがちです。ここで便利なのがDockerです。Dockerを使用することで、開発環境やデータベースのセットアップを一貫して管理し、開発チーム全員が同じ環境で作業できるようになります。

本記事では、RustのプロジェクトでDockerを活用し、データベース環境をセットアップする方法を解説します。Docker Composeを使ったデータベースの構築から、Rustコードでの接続方法、CRUD操作の実装、Docker環境でのデバッグ方法まで、ステップごとにわかりやすく説明します。これにより、効率的なRust開発環境の構築が可能になり、スムーズな開発ワークフローを実現できるでしょう。

目次
  1. RustとDockerの基本概要
    1. Rustの概要
    2. Dockerの概要
    3. Rust × Dockerのメリット
  2. 必要なツールと環境の準備
    1. 1. Rustのインストール
    2. 2. Cargoの確認
    3. 3. Dockerのインストール
    4. 4. Docker Composeのインストール
    5. 5. データベース用のDockerイメージの準備
    6. 6. 必要なRustクレートの追加
    7. 環境の確認
  3. Docker Composeを使ったデータベース構築
    1. 1. `docker-compose.yml`ファイルの作成
    2. 2. Docker Composeでコンテナを起動
    3. 3. コンテナの状態を確認
    4. 4. データベースへの接続確認
    5. 5. コンテナの停止と削除
    6. これでデータベース環境が完成
  4. Rustプロジェクトの作成と設定
    1. 1. 新しいRustプロジェクトの作成
    2. 2. データベース関連クレートの追加
    3. 3. 環境変数ファイルの作成
    4. 4. 環境変数を読み込む設定
    5. 5. プロジェクトのビルドと実行
    6. 6. データベース接続の基本設定
  5. Rustからデータベースへの接続方法
    1. 1. 必要なクレートの確認
    2. 2. 環境変数の設定
    3. 3. データベース接続コードの作成
    4. 4. コードの説明
    5. 5. プロジェクトのビルドと実行
    6. 6. エラーが発生した場合の対処法
  6. CRUD操作の実装
    1. 1. テーブルの作成
    2. 2. Create（データの追加）
    3. 3. Read（データの取得）
    4. 4. Update（データの更新）
    5. 5. Delete（データの削除）
    6. 6. `main`関数からCRUD操作を呼び出す
    7. 7. プロジェクトのビルドと実行
    8. これでCRUD操作の実装完了
  7. Docker環境でのデバッグとエラー対処法
    1. 1. Dockerコンテナのログ確認
    2. 2. Dockerコンテナ内でのデバッグ
    3. 3. Rustアプリケーションのエラーログ確認
    4. 4. データベースの状態確認
    5. 5. コード内のデバッグ用出力
    6. 6. デバッグビルドの使用
    7. 7. Docker Composeでエラーが出た場合の対処
    8. 8. Dockerネットワークの確認
    9. まとめ
  8. 実用例とベストプラクティス
    1. 1. ユーザー管理APIの実装例
    2. 2. Docker ComposeでRustアプリとデータベースを連携
    3. 3. Dockerfileの作成
    4. 4. デプロイのベストプラクティス
    5. 5. 開発とデバッグの効率化
    6. まとめ
  9. まとめ

RustとDockerの基本概要


RustとDockerを使うことで、効率的かつ安全にアプリケーション開発ができます。まず、それぞれの基本概要と利点を見ていきましょう。

Rustの概要


Rustは、Mozillaが開発したシステムプログラミング言語で、主に以下の特徴があります。

  • 安全性：メモリ安全を保証し、ランタイムエラーやデータ競合を防ぐ。
  • 高パフォーマンス：C++に匹敵する速度で動作。
  • 型システムの堅牢性：コンパイル時にバグを検出し、コードの品質を高める。

RustはWebバックエンドや、ネットワークツール、コマンドラインアプリケーションに広く利用されています。

Dockerの概要


Dockerは、アプリケーションをコンテナという仮想化環境で実行するツールです。以下の利点があります。

  • 環境の一貫性：開発、テスト、本番環境で同じ環境を再現できる。
  • 依存関係の管理：OSやライブラリの依存関係をコンテナにカプセル化。
  • 迅速なデプロイ：コンテナイメージを使用して、アプリケーションを簡単にデプロイ。

Rust × Dockerのメリット


RustとDockerを組み合わせることで、以下のメリットが得られます。

  • 開発環境の統一：チーム全体で同じ環境を維持できる。
  • 簡単なデータベース管理：Dockerを使えばデータベースのセットアップが手軽になる。
  • CI/CDの効率化：Dockerイメージを活用し、継続的インテグレーション・デリバリーを自動化。

Rustの高性能とDockerの柔軟な環境構築を組み合わせることで、効率的なアプリケーション開発が可能になります。

必要なツールと環境の準備


RustとDockerを使用してデータベース連携を行うためには、いくつかのツールと環境の準備が必要です。以下のステップで準備を整えましょう。

1. Rustのインストール


Rustのインストールには、公式ツールであるrustupを使用します。ターミナルで以下のコマンドを実行します。

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

インストールが完了したら、Rustのバージョンを確認します。

rustc --version

2. Cargoの確認


CargoはRustのパッケージマネージャー兼ビルドツールです。rustupでRustをインストールすると、Cargoも自動的にインストールされます。

Cargoがインストールされているか確認します。

cargo --version

3. Dockerのインストール


Dockerのインストールは公式サイトから行えます。以下のリンクからダウンロードしてインストールします。
Docker公式ダウンロードページ

インストール後、Dockerが正常に動作しているか確認します。

docker --version

4. Docker Composeのインストール


Docker Composeは複数のコンテナを一括で管理するためのツールです。Docker Desktopをインストールすると、Docker Composeも含まれます。バージョン確認を行います。

docker-compose --version

5. データベース用のDockerイメージの準備


今回は、PostgreSQLを使用する例を取り上げます。以下のコマンドでPostgreSQLのDockerイメージをダウンロードします。

docker pull postgres:latest

6. 必要なRustクレートの追加


データベースに接続するためのクレート（ライブラリ）をCargo.tomlに追加します。以下はpostgresクレートの例です。

[dependencies]
tokio = { version = "1", features = ["full"] }
postgres = "0.19"

環境の確認


すべてのツールが正しくインストールされているか、以下のコマンドで最終確認します。

rustc --version
cargo --version
docker --version
docker-compose --version

これでRustとDockerの開発環境が整いました。次のステップでは、Docker Composeを使ってデータベース環境を構築していきます。

Docker Composeを使ったデータベース構築


Rustアプリケーションでデータベースを利用するために、Docker Composeを使用してデータベースコンテナをセットアップします。ここでは、PostgreSQLを例に構築手順を説明します。

1. `docker-compose.yml`ファイルの作成


Rustプロジェクトのルートディレクトリにdocker-compose.ymlファイルを作成し、以下の内容を記述します。

version: '3.8'

services:
  db:
    image: postgres:latest
    container_name: rust_postgres_db
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: rust_db
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

各セクションの説明：

  • services：コンテナ化するサービスの定義。
  • db：PostgreSQLデータベースのサービス名。
  • image：使用するDockerイメージ。ここではpostgres:latestを使用。
  • environment：データベースのユーザー名、パスワード、データベース名を設定。
  • ports：ホストマシンとコンテナのポートを対応付け。
  • volumes：データの永続化用ボリューム。

2. Docker Composeでコンテナを起動


ターミナルで以下のコマンドを実行し、データベースコンテナを起動します。

docker-compose up -d

オプション：

  • -d：バックグラウンドでコンテナを起動します。

3. コンテナの状態を確認


コンテナが正常に起動したか確認するには、以下のコマンドを実行します。

docker-compose ps

出力例：

      Name                    Command               State           Ports
---------------------------------------------------------------------------------
rust_postgres_db   docker-entrypoint.sh postgres   Up      0.0.0.0:5432->5432/tcp

4. データベースへの接続確認


以下のコマンドでコンテナ内に入り、PostgreSQLの接続確認を行います。

docker exec -it rust_postgres_db psql -U user -d rust_db

成功すると、以下のようなPostgreSQLシェルに入れます。

rust_db=#

5. コンテナの停止と削除


データベースコンテナを停止するには以下のコマンドを使用します。

docker-compose down

これでデータベース環境が完成


Docker Composeを利用してPostgreSQLデータベースのセットアップが完了しました。次はRustアプリケーションからこのデータベースに接続し、データ操作を行う方法を解説します。

Rustプロジェクトの作成と設定


Dockerでデータベース環境をセットアップしたら、Rustプロジェクトを作成し、データベース接続の準備を整えます。以下の手順でRustプロジェクトをセットアップしましょう。

1. 新しいRustプロジェクトの作成


Cargoを使って新しいRustプロジェクトを作成します。ターミナルで以下のコマンドを実行します。

cargo new rust_docker_db
cd rust_docker_db

これにより、以下のディレクトリ構造が作成されます。

rust_docker_db/
├── Cargo.toml
└── src/
    └── main.rs

2. データベース関連クレートの追加


データベースに接続するためのクレートをCargo.tomlに追加します。ここでは、tokio（非同期ランタイム）とpostgresクレートを使用します。

Cargo.tomlに以下の依存関係を追加します。

[dependencies]
tokio = { version = "1", features = ["full"] }
postgres = "0.19"
dotenv = "0.15"    # 環境変数の読み込み用

3. 環境変数ファイルの作成


データベースの接続情報を管理するため、.envファイルを作成します。プロジェクトのルートディレクトリに以下の内容で作成します。

.envファイル：

DATABASE_URL=postgres://user:password@localhost:5432/rust_db

4. 環境変数を読み込む設定


main.rsで.envファイルの内容を読み込むように設定します。

src/main.rs：

use dotenv::dotenv;
use std::env;

fn main() {
    dotenv().ok();

    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    println!("Database URL: {}", database_url);
}

5. プロジェクトのビルドと実行


プロジェクトをビルドして実行し、環境変数が正しく読み込まれているか確認します。

cargo run

出力例：

Database URL: postgres://user:password@localhost:5432/rust_db

6. データベース接続の基本設定


次のステップでデータベースに接続するコードを追加する準備が整いました。main.rsにデータベース接続用の関数を追加し、データベースとの連携を進めます。

これでRustプロジェクトの初期設定が完了です。次のステップでは、Rustからデータベースに接続する方法を解説します。

Rustからデータベースへの接続方法


RustでPostgreSQLデータベースに接続する方法を具体的に解説します。ここでは、tokioを使用した非同期プログラムで、データベースへの接続を確立します。

1. 必要なクレートの確認


Cargo.tomlで、以下のクレートが依存関係として追加されていることを確認します。

[dependencies]
tokio = { version = "1", features = ["full"] }
postgres = "0.19"
dotenv = "0.15"

2. 環境変数の設定


データベース接続情報は.envファイルで管理します。以下の内容が正しく設定されていることを確認してください。

.envファイル：

DATABASE_URL=postgres://user:password@localhost:5432/rust_db

3. データベース接続コードの作成


src/main.rsにデータベースへの接続コードを追加します。

src/main.rs：

use dotenv::dotenv;
use std::env;
use tokio;
use tokio_postgres::{Client, NoTls, Error};

#[tokio::main]
async fn main() -> Result<(), Error> {
    // .envファイルを読み込む
    dotenv().ok();

    // DATABASE_URLを環境変数から取得
    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");

    // PostgreSQLに接続
    let (client, connection) = tokio_postgres::connect(&database_url, NoTls).await?;

    // 接続エラー処理
    tokio::spawn(async move {
        if let Err(e) = connection.await {
            eprintln!("Connection error: {}", e);
        }
    });

    println!("Successfully connected to the database!");

    // テーブル作成などの処理をここに追加できます

    Ok(())
}

4. コードの説明

  • dotenv()：.envファイルを読み込みます。
  • env::var(“DATABASE_URL”)：環境変数からデータベースのURLを取得します。
  • tokio_postgres::connect()：非同期でPostgreSQLに接続します。
  • tokio::spawn()：接続の処理をバックグラウンドで実行し、エラーがあれば出力します。

5. プロジェクトのビルドと実行


ターミナルで以下のコマンドを実行して、データベース接続が成功するか確認します。

cargo run

出力例：

Successfully connected to the database!

6. エラーが発生した場合の対処法


接続エラーが発生した場合、以下のポイントを確認してください。

  1. データベースが起動しているか：Dockerコンテナが起動していることを確認します。
   docker-compose ps
  1. 環境変数の設定：.envファイルの内容が正しいか確認します。
  2. ネットワーク設定：PostgreSQLのポートが5432でホストとコンテナが正しくマッピングされているか確認します。

これでRustからPostgreSQLデータベースに接続できるようになりました。次のステップでは、データベースに対するCRUD操作の実装方法を解説します。

CRUD操作の実装


RustからPostgreSQLデータベースに接続したら、次にCRUD操作（Create、Read、Update、Delete）を実装しましょう。tokio_postgresクレートを使用し、非同期でデータベース操作を行います。

1. テーブルの作成


まず、データベースにテーブルを作成します。usersテーブルを作成するSQLクエリを実行します。

src/main.rs：

use dotenv::dotenv;
use std::env;
use tokio;
use tokio_postgres::{NoTls, Error};

#[tokio::main]
async fn main() -> Result<(), Error> {
    dotenv().ok();
    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");

    let (client, connection) = tokio_postgres::connect(&database_url, NoTls).await?;
    tokio::spawn(async move {
        if let Err(e) = connection.await {
            eprintln!("Connection error: {}", e);
        }
    });

    // テーブル作成クエリ
    client
        .execute(
            "CREATE TABLE IF NOT EXISTS users (
                id SERIAL PRIMARY KEY,
                name VARCHAR(100),
                email VARCHAR(100)
            )",
            &[],
        )
        .await?;

    println!("Table created successfully!");

    Ok(())
}

2. Create（データの追加）


新しいユーザーをテーブルに追加する関数を作成します。

async fn add_user(client: &tokio_postgres::Client, name: &str, email: &str) -> Result<(), Error> {
    client
        .execute(
            "INSERT INTO users (name, email) VALUES ($1, $2)",
            &[&name, &email],
        )
        .await?;
    println!("User added successfully!");
    Ok(())
}

3. Read（データの取得）


テーブルからすべてのユーザーを取得し、表示する関数を作成します。

async fn get_users(client: &tokio_postgres::Client) -> Result<(), Error> {
    let rows = client.query("SELECT id, name, email FROM users", &[]).await?;

    for row in rows {
        let id: i32 = row.get(0);
        let name: &str = row.get(1);
        let email: &str = row.get(2);
        println!("ID: {}, Name: {}, Email: {}", id, name, email);
    }

    Ok(())
}

4. Update（データの更新）


既存のユーザー情報を更新する関数を作成します。

async fn update_user_email(client: &tokio_postgres::Client, id: i32, new_email: &str) -> Result<(), Error> {
    client
        .execute(
            "UPDATE users SET email = $1 WHERE id = $2",
            &[&new_email, &id],
        )
        .await?;
    println!("User email updated successfully!");
    Ok(())
}

5. Delete（データの削除）


ユーザーを削除する関数を作成します。

async fn delete_user(client: &tokio_postgres::Client, id: i32) -> Result<(), Error> {
    client
        .execute(
            "DELETE FROM users WHERE id = $1",
            &[&id],
        )
        .await?;
    println!("User deleted successfully!");
    Ok(())
}

6. `main`関数からCRUD操作を呼び出す


main関数にCRUD操作の関数呼び出しを追加します。

#[tokio::main]
async fn main() -> Result<(), Error> {
    dotenv().ok();
    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");

    let (client, connection) = tokio_postgres::connect(&database_url, NoTls).await?;
    tokio::spawn(async move {
        if let Err(e) = connection.await {
            eprintln!("Connection error: {}", e);
        }
    });

    // テーブル作成
    client.execute(
        "CREATE TABLE IF NOT EXISTS users (
            id SERIAL PRIMARY KEY,
            name VARCHAR(100),
            email VARCHAR(100)
        )",
        &[],
    ).await?;

    // CRUD操作の呼び出し
    add_user(&client, "Alice", "alice@example.com").await?;
    get_users(&client).await?;
    update_user_email(&client, 1, "alice@newdomain.com").await?;
    delete_user(&client, 1).await?;
    get_users(&client).await?;

    Ok(())
}

7. プロジェクトのビルドと実行


以下のコマンドでプロジェクトをビルド・実行し、CRUD操作が正常に動作するか確認します。

cargo run

出力例：

Table created successfully!
User added successfully!
ID: 1, Name: Alice, Email: alice@example.com
User email updated successfully!
User deleted successfully!

これでCRUD操作の実装完了


これでRustを使ったPostgreSQLデータベースへのCRUD操作が実装できました。次のステップでは、Docker環境でのデバッグ方法やエラー対処法について解説します。

Docker環境でのデバッグとエラー対処法


RustとDockerを組み合わせた開発環境では、デバッグやエラー解決が重要です。Dockerコンテナ内のデータベースとの接続エラーやRustアプリケーションの問題を効率的に特定・修正する方法を解説します。

1. Dockerコンテナのログ確認


データベースのエラーが発生した場合、まずDockerコンテナのログを確認しましょう。

docker-compose logs db

出力例：

2024-04-25 10:12:34.567 UTC [1] LOG:  database system is ready to accept connections

エラーがある場合、エラーメッセージが表示されます。

2. Dockerコンテナ内でのデバッグ


Dockerコンテナに直接入ってデータベースの状態を確認できます。以下のコマンドでコンテナ内にアクセスします。

docker exec -it rust_postgres_db bash

コンテナ内でPostgreSQLシェルに接続：

psql -U user -d rust_db

3. Rustアプリケーションのエラーログ確認


Rustアプリケーションでエラーが発生した場合、エラーメッセージを確認します。

cargo run

出力例：

Error: connection refused (os error 61)

エラー例と対処法：

  • connection refused：
    データベースが起動していない可能性があります。
  docker-compose up -d
  • password authentication failed：
    環境変数のユーザー名またはパスワードが正しいか確認します。

4. データベースの状態確認


データベースに正しく接続できるか以下のSQLコマンドで確認します。

SELECT * FROM users;

5. コード内のデバッグ用出力


Rustのコードにデバッグ用の出力を追加して、変数の値や関数の進行状況を確認します。

println!("Connecting to the database...");

6. デバッグビルドの使用


Rustのデバッグビルドを使うことで、最適化されていない詳細なエラーメッセージが得られます。

cargo build

7. Docker Composeでエラーが出た場合の対処


Docker Composeの設定ミスがある場合、以下を確認します。

  • ポートの競合：
    別のサービスが5432ポートを使用している可能性があります。別のポートに変更しましょう。
  ports:
    - "5433:5432"
  • 環境変数の確認：
    .envファイルの内容が正しいか確認してください。

8. Dockerネットワークの確認


コンテナ間でネットワーク接続ができているか確認します。

docker network ls

必要に応じてネットワークを再作成：

docker-compose down
docker-compose up -d

まとめ


Docker環境でのデバッグは、コンテナログの確認、コンテナ内アクセス、Rustコードへのデバッグ出力追加などが効果的です。エラーの原因を特定し、効率的に修正していきましょう。次は、RustとDockerの実用例やベストプラクティスについて解説します。

実用例とベストプラクティス


RustとDockerを活用したデータベース連携の開発において、実際のプロジェクトで役立つ具体的な例とベストプラクティスを紹介します。これにより、効率的で保守性の高い開発が可能になります。

1. ユーザー管理APIの実装例


Rustでシンプルなユーザー管理APIを作成し、データベースと連携させる例を示します。

src/main.rs：

use actix_web::{web, App, HttpResponse, HttpServer, Responder};
use dotenv::dotenv;
use std::env;
use tokio_postgres::{NoTls, Client};

async fn get_users(client: web::Data<Client>) -> impl Responder {
    let rows = client.query("SELECT id, name, email FROM users", &[]).await;

    match rows {
        Ok(rows) => {
            let users: Vec<String> = rows.iter()
                .map(|row| format!("ID: {}, Name: {}, Email: {}", row.get::<usize, i32>(0), row.get::<usize, &str>(1), row.get::<usize, &str>(2)))
                .collect();
            HttpResponse::Ok().body(users.join("\n"))
        }
        Err(_) => HttpResponse::InternalServerError().body("Error fetching users"),
    }
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    dotenv().ok();
    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");

    let (client, connection) = tokio_postgres::connect(&database_url, NoTls).await.expect("Failed to connect to database");

    tokio::spawn(async move {
        if let Err(e) = connection.await {
            eprintln!("Connection error: {}", e);
        }
    });

    let client_data = web::Data::new(client);

    HttpServer::new(move || {
        App::new()
            .app_data(client_data.clone())
            .route("/users", web::get().to(get_users))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

このコードはactix-webを使用して、ユーザー一覧を取得するエンドポイントを提供します。

2. Docker ComposeでRustアプリとデータベースを連携


Rustアプリケーションとデータベースを一括で管理するdocker-compose.ymlの設定例です。

docker-compose.yml：

version: '3.8'

services:
  db:
    image: postgres:latest
    container_name: rust_postgres_db
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: rust_db
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

  app:
    build: .
    container_name: rust_app
    environment:
      DATABASE_URL: postgres://user:password@db:5432/rust_db
    ports:
      - "8080:8080"
    depends_on:
      - db

volumes:
  postgres_data:

ディレクトリ構造：

rust_project/
├── Dockerfile
├── docker-compose.yml
├── Cargo.toml
└── src/
    └── main.rs

3. Dockerfileの作成


RustアプリケーションのDockerイメージをビルドするためのDockerfileを作成します。

Dockerfile：

FROM rust:latest

WORKDIR /app

COPY . .

RUN cargo build --release

CMD ["./target/release/rust_project"]

4. デプロイのベストプラクティス

  • マルチステージビルド：ビルドと実行を分けてイメージサイズを最小化する。
  • 環境変数の管理：.envファイルを使用し、機密情報をソースコードに直接書かない。
  • CI/CDパイプライン：GitHub ActionsやGitLab CIでビルドとテストを自動化。
  • ボリュームの永続化：データベースデータを永続化し、コンテナが再起動してもデータを保持。

5. 開発とデバッグの効率化

  • ホットリロードの導入：cargo-watchを使って変更を検知し、自動的にビルド・再起動。
  cargo install cargo-watch
  cargo watch -x run
  • ログの活用：env_loggerクレートを使用してログレベルごとに出力。
  [dependencies]
  env_logger = "0.10"

まとめ


RustとDockerを活用したデータベース連携の実用例とベストプラクティスを紹介しました。これらを適用することで、効率的な開発環境を構築し、デプロイの自動化やエラー管理をスムーズに行うことができます。次は本記事のまとめです。

まとめ


本記事では、RustとDockerを活用してデータベース環境をセットアップし、連携する方法について解説しました。Docker Composeを使用したデータベース構築から、Rustアプリケーションでのデータベース接続、CRUD操作の実装、デバッグやエラー対処法、さらには実用例とベストプラクティスまで、ステップごとに紹介しました。

Rustの高パフォーマンスと安全性、Dockerの環境構築と管理の柔軟性を組み合わせることで、効率的で再現性の高い開発環境を実現できます。これにより、開発、テスト、デプロイがスムーズに行え、チーム全体で一貫したワークフローを維持できるでしょう。

この記事を参考にして、RustとDockerを活用したプロジェクトを構築し、モダンな開発環境を最大限に活用してください。

Rust
データベース Docker 開発環境 Rust

コメント

コメントする

目次
  1. RustとDockerの基本概要
    1. Rustの概要
    2. Dockerの概要
    3. Rust × Dockerのメリット
  2. 必要なツールと環境の準備
    1. 1. Rustのインストール
    2. 2. Cargoの確認
    3. 3. Dockerのインストール
    4. 4. Docker Composeのインストール
    5. 5. データベース用のDockerイメージの準備
    6. 6. 必要なRustクレートの追加
    7. 環境の確認
  3. Docker Composeを使ったデータベース構築
    1. 1. `docker-compose.yml`ファイルの作成
    2. 2. Docker Composeでコンテナを起動
    3. 3. コンテナの状態を確認
    4. 4. データベースへの接続確認
    5. 5. コンテナの停止と削除
    6. これでデータベース環境が完成
  4. Rustプロジェクトの作成と設定
    1. 1. 新しいRustプロジェクトの作成
    2. 2. データベース関連クレートの追加
    3. 3. 環境変数ファイルの作成
    4. 4. 環境変数を読み込む設定
    5. 5. プロジェクトのビルドと実行
    6. 6. データベース接続の基本設定
  5. Rustからデータベースへの接続方法
    1. 1. 必要なクレートの確認
    2. 2. 環境変数の設定
    3. 3. データベース接続コードの作成
    4. 4. コードの説明
    5. 5. プロジェクトのビルドと実行
    6. 6. エラーが発生した場合の対処法
  6. CRUD操作の実装
    1. 1. テーブルの作成
    2. 2. Create（データの追加）
    3. 3. Read（データの取得）
    4. 4. Update（データの更新）
    5. 5. Delete（データの削除）
    6. 6. `main`関数からCRUD操作を呼び出す
    7. 7. プロジェクトのビルドと実行
    8. これでCRUD操作の実装完了
  7. Docker環境でのデバッグとエラー対処法
    1. 1. Dockerコンテナのログ確認
    2. 2. Dockerコンテナ内でのデバッグ
    3. 3. Rustアプリケーションのエラーログ確認
    4. 4. データベースの状態確認
    5. 5. コード内のデバッグ用出力
    6. 6. デバッグビルドの使用
    7. 7. Docker Composeでエラーが出た場合の対処
    8. 8. Dockerネットワークの確認
    9. まとめ
  8. 実用例とベストプラクティス
    1. 1. ユーザー管理APIの実装例
    2. 2. Docker ComposeでRustアプリとデータベースを連携
    3. 3. Dockerfileの作成
    4. 4. デプロイのベストプラクティス
    5. 5. 開発とデバッグの効率化
    6. まとめ
  9. まとめ