MENU
  1. ホーム
  2. Rust
  3. Rust開発者必見！人気の外部クレート徹底解説：serde, tokio, rand

Rust開発者必見！人気の外部クレート徹底解説：serde, tokio, rand

Rust

Rustは、その高速性、安全性、そしてエコシステムの豊かさで広く知られるプログラミング言語です。その中でも特に重要なのが、Rustのエコシステムを支える「外部クレート」です。外部クレートとは、Rustコミュニティによって公開されているライブラリで、開発者がプロジェクトを効率的に進めるための便利な機能を提供します。この記事では、Rust開発者が知っておくべき人気の外部クレート、serde、tokio、randを中心に、その特徴や使用方法を詳しく解説します。これにより、Rustプロジェクトの効率化やパフォーマンス向上のためのヒントを得られるでしょう。

目次
  1. Rustの外部クレートとは
    1. 外部クレートの特徴
    2. 外部クレートの利用方法
    3. 外部クレートの利点
  2. データシリアライゼーションの標準：serde
    1. serdeとは
    2. serdeの主な特徴
    3. serdeのセットアップ方法
    4. serdeの活用例
    5. 用途とメリット
  3. 非同期プログラミングの主力：tokio
    1. tokioとは
    2. tokioの主な特徴
    3. tokioのセットアップ方法
    4. tokioの活用例
    5. 用途とメリット
  4. ランダム性の強力なサポート：rand
    1. randとは
    2. randの主な特徴
    3. randのセットアップ方法
    4. randの活用例
    5. 用途とメリット
    6. 注意点
  5. 外部クレートを活用するためのベストプラクティス
    1. 目的に合ったクレートを選定する
    2. 適切なバージョン管理
    3. クレートのドキュメントを活用する
    4. 依存関係の肥大化を防ぐ
    5. テスト環境での使用確認
    6. セキュリティを意識する
    7. 定期的な依存関係の更新
  6. クレートの依存関係管理の実践例
    1. 依存関係管理とは
    2. 依存関係管理の基本
    3. 依存関係の確認と監視
    4. 依存関係の競合を解消する
    5. 依存関係の安全性を確保する
    6. 具体例：依存関係を効率的に管理するRustプロジェクト
    7. 依存関係管理の重要性
  7. セキュリティ考慮のためのクレート監査手法
    1. クレート監査の重要性
    2. 監査ツールの活用
    3. 手動でのコードレビュー
    4. 依存関係の最小化
    5. 安全なクレートの選択基準
    6. セキュリティ強化のための継続的な監視
    7. クレート監査のまとめ
  8. 演習：Rustプロジェクトに外部クレートを導入する
    1. 目標
    2. 演習手順
    3. 学習ポイント
    4. 応用課題
  9. まとめ

Rustの外部クレートとは


Rustの外部クレートは、他の開発者が公開しているライブラリやモジュールのことで、Rustの標準ライブラリではカバーしきれない特定の機能を提供します。これにより、プロジェクトの開発スピードを向上させるだけでなく、コードの再利用性やメンテナンス性も向上します。

外部クレートの特徴


Rustの外部クレートは、多くの場合、Cargoを介して簡単にインストールし、利用できます。以下の特徴があります。

  • オープンソース：多くのクレートはコミュニティで管理され、継続的に更新されています。
  • 高品質：Rustコミュニティでは、コードの品質を高めるために厳しいレビューが行われています。
  • 豊富な種類：非同期プログラミング、データ処理、数値計算など、多様な用途に対応するクレートがあります。

外部クレートの利用方法


外部クレートを利用する際には、以下の手順を実行します。

  1. クレートの検索
    Rust公式クレートリポジトリであるcrates.ioを使用して、目的に合ったクレートを検索します。
  2. Cargo.tomlに追加
    使用するクレートをプロジェクトのCargo.tomlファイルに記述します。例えば、serdeを使用する場合：
   [dependencies]
   serde = "1.0"
  1. コードにインポート
    必要なモジュールをコードで使用できるようにインポートします。例えば：
   use serde::{Serialize, Deserialize};

外部クレートの利点


外部クレートを活用することで、以下の利点を享受できます。

  • 時間の節約：既存のライブラリを使用することで、ゼロからコードを書く必要がありません。
  • コミュニティの力を活用：多くの外部クレートは広く利用され、テスト済みです。
  • 迅速なバグ修正とアップデート：定期的な更新で最新機能が利用できます。

Rustの外部クレートは、プロジェクトを強化し、効率的に開発を進めるための強力なツールです。次に、具体的なクレートの例を見ていきましょう。

データシリアライゼーションの標準：serde

serdeとは


serdeは、Rustでデータのシリアライズ（構造化データを文字列やバイト列に変換すること）とデシリアライズ（文字列やバイト列を構造化データに戻すこと）を行うためのライブラリです。JSON、YAML、TOMLなどの多くのフォーマットをサポートしており、Rustで構造化データを扱う際には欠かせないクレートです。

serdeの主な特徴

  • 高速性：高いパフォーマンスを提供し、Rustの速度を活かした処理が可能です。
  • 使いやすさ：Rustの型システムとシームレスに連携します。
  • 拡張性：カスタムシリアライズロジックや非同期対応のモジュールも利用可能です。

serdeのセットアップ方法


serdeを使用するには、以下の手順を実行します。

  1. Cargo.tomlに依存関係を追加
   [dependencies]
   serde = { version = "1.0", features = ["derive"] }
   serde_json = "1.0" # JSONフォーマットを使用する場合
  1. Rustコードで使用
    必要なモジュールをインポートし、データ型にSerializeとDeserializeトレイトを導入します。
   use serde::{Serialize, Deserialize};

   #[derive(Serialize, Deserialize)]
   struct User {
       id: u32,
       name: String,
       email: String,
   }

serdeの活用例

JSONを使ったシリアライズとデシリアライズ
以下のコードは、JSON文字列に変換し、再びRust構造体に戻す例です：

fn main() {
    use serde_json;

    #[derive(Serialize, Deserialize, Debug)]
    struct User {
        id: u32,
        name: String,
        email: String,
    }

    // 構造体をJSON文字列に変換
    let user = User {
        id: 1,
        name: "Alice".to_string(),
        email: "alice@example.com".to_string(),
    };
    let json_string = serde_json::to_string(&user).unwrap();
    println!("Serialized: {}", json_string);

    // JSON文字列を構造体に変換
    let deserialized: User = serde_json::from_str(&json_string).unwrap();
    println!("Deserialized: {:?}", deserialized);
}

用途とメリット

  • APIとのデータ交換：REST APIでJSONデータを送受信する場面で役立ちます。
  • 設定ファイルの読み書き：TOMLやYAML形式の設定ファイルを扱う際に便利です。
  • データの永続化：アプリケーションデータを保存する場合に簡単に利用できます。

serdeは、その汎用性と性能の高さから、Rustでデータを操作する際の第一選択肢となるクレートです。次は非同期プログラミングに不可欠なtokioについて解説します。

非同期プログラミングの主力：tokio

tokioとは


tokioは、Rustにおける非同期プログラミングを実現するためのライブラリで、スケーラブルで高性能な非同期ランタイムを提供します。ネットワークアプリケーションやリアルタイムシステムの開発に最適です。

tokioの主な特徴

  • スケーラブルな非同期ランタイム：大量のタスクを効率よく処理できます。
  • 柔軟な設計：TCP、UDP、WebSocketなどの通信プロトコルに対応しています。
  • エコシステムの充実：多くの関連クレート（例：hyper、tonic）が存在し、機能拡張が容易です。

tokioのセットアップ方法

  1. Cargo.tomlに依存関係を追加
    以下のようにtokioをプロジェクトに追加します：
   [dependencies]
   tokio = { version = "1", features = ["full"] }
  1. 非同期コードの作成
    Rustで非同期コードを動かすには、asyncとawaitを組み合わせます。以下にtokioの基本的な使用例を示します：
   #[tokio::main]
   async fn main() {
       let result = tokio::spawn(async {
           println!("Hello from an async task!");
       });

       result.await.unwrap();
   }

tokioの活用例

非同期TCPサーバーの実装
以下は簡単な非同期TCPサーバーの例です：

use tokio::net::TcpListener;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> tokio::io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?;

    loop {
        let (mut socket, addr) = listener.accept().await?;
        println!("New connection: {}", addr);

        tokio::spawn(async move {
            let mut buf = vec![0; 1024];

            // データを読み取る
            let n = socket.read(&mut buf).await.unwrap();
            println!("Received: {}", String::from_utf8_lossy(&buf[..n]));

            // 応答を送信
            socket.write_all(b"Hello from server!\n").await.unwrap();
        });
    }
}

用途とメリット

  • ネットワークアプリケーション：HTTPサーバー、チャットアプリ、ゲームサーバーなどに適しています。
  • リアルタイムシステム：金融市場の取引アプリケーションやIoTシステムで非同期処理が役立ちます。
  • 高性能：非同期処理により、シングルスレッドでも多数の接続を効率的に管理できます。

tokioは、非同期プログラミングを簡素化し、Rustのパフォーマンスを最大限に引き出すための強力なツールです。次はランダム値生成を支援するrandについて解説します。

ランダム性の強力なサポート：rand

randとは


randは、Rustでランダムな値を生成するための標準的なライブラリです。乱数の生成だけでなく、配列のシャッフルや統計的分布に基づいた値の生成など、多様な機能を提供します。

randの主な特徴

  • 使いやすいAPI：直感的なインターフェースで簡単に乱数を生成できます。
  • 豊富な機能：一様分布、正規分布、離散分布など、さまざまな分布に対応。
  • 安全性：Rustの型システムを活用し、安全で信頼性の高い乱数生成が可能です。

randのセットアップ方法

  1. Cargo.tomlに依存関係を追加
    プロジェクトにrandクレートを追加します：
   [dependencies]
   rand = "0.8"
  1. 基本的な乱数の生成
    以下のコードで乱数を生成します：
   use rand::Rng;

   fn main() {
       let mut rng = rand::thread_rng();
       let random_number: u32 = rng.gen_range(1..=100); // 1から100までの乱数
       println!("Generated random number: {}", random_number);
   }

randの活用例

配列のシャッフル
randを使って配列をランダムに並び替えることができます：

use rand::seq::SliceRandom;

fn main() {
    let mut items = vec![1, 2, 3, 4, 5];
    let mut rng = rand::thread_rng();
    items.shuffle(&mut rng);

    println!("Shuffled array: {:?}", items);
}

カスタム分布に基づいた乱数生成
以下の例は正規分布に基づいた乱数を生成します：

use rand_distr::{Normal, Distribution};

fn main() {
    let normal = Normal::new(0.0, 1.0).unwrap(); // 平均0、標準偏差1の正規分布
    let mut rng = rand::thread_rng();

    let value: f64 = normal.sample(&mut rng);
    println!("Random value from normal distribution: {}", value);
}

用途とメリット

  • ゲーム開発：ゲーム内のランダムなイベントや乱数を利用した動作に活用できます。
  • 統計解析：分布に基づいたデータ生成やシミュレーションに最適です。
  • セキュリティ：暗号学的に安全な乱数を生成する機能（例：rand::rngs::OsRng）も利用可能です。

注意点


セキュリティ関連の用途では、暗号学的に安全な乱数生成（rand::rngs::OsRngなど）を使用する必要があります。

randは、Rustでのランダム性の取り扱いを簡素化し、多様なユースケースに対応する柔軟なライブラリです。次に、外部クレートを効果的に活用するためのベストプラクティスを見ていきましょう。

外部クレートを活用するためのベストプラクティス

目的に合ったクレートを選定する


Rustのエコシステムには、多くの外部クレートが存在します。その中から適切なクレートを選ぶことがプロジェクト成功の鍵となります。以下のポイントを考慮してクレートを選定しましょう：

  • 利用頻度と信頼性：crates.ioでのダウンロード数やGitHubのスター数が多いクレートは、多くの開発者に支持されており信頼性が高いです。
  • メンテナンス状況：最近の更新履歴を確認し、活発にメンテナンスされているかを確認します。
  • ドキュメントの充実度：公式ドキュメントや使用例が充実しているクレートを選びましょう。

適切なバージョン管理


Rustでは、Cargo.tomlでクレートのバージョンを指定します。適切なバージョン指定により、依存関係の問題を防ぐことができます。

  • セマンティックバージョニング：互換性を保ちながら最新のバグ修正を取り入れるために、キャレット演算子（例：serde = "1.0"）を使用します。
  • 固定バージョン：長期的なプロジェクトでは、特定のバージョンを固定することで、予期せぬ問題を防ぎます。

クレートのドキュメントを活用する


クレートの公式ドキュメントは、機能の詳細や使用例を学ぶための重要なリソースです。特に以下のポイントを確認すると良いでしょう：

  • 主要なAPIの使い方
  • 推奨される設定方法
  • エラーハンドリングの例

依存関係の肥大化を防ぐ


外部クレートの多用は便利ですが、依存関係が増えることで以下のリスクが生じます：

  • ビルド時間の増加：依存関係が増えると、プロジェクトのビルド時間が長くなります。
  • セキュリティリスク：未検証のクレートを使用すると、潜在的なセキュリティリスクが高まります。

依存関係を管理するためには、以下を実践しましょう：

  • 必要最小限のクレートのみを使用する。
  • 使用しなくなったクレートはCargo.tomlから削除する。

テスト環境での使用確認


外部クレートを導入したら、テスト環境で十分に検証を行いましょう。以下のテスト方法を推奨します：

  • ユニットテスト：特定の機能に対するテストを行い、クレートの導入効果を確認します。
  • インテグレーションテスト：プロジェクト全体でクレートが正しく動作するかを検証します。

セキュリティを意識する


Rustでは外部クレートの利用が多いほどセキュリティリスクが増大します。以下の対策を講じることで、安全な開発を行えます：

  • cargo auditの活用：既知の脆弱性をチェックできます。
  • コードレビュー：重要なプロジェクトでは、依存クレートのソースコードを確認することも検討してください。

定期的な依存関係の更新


cargo updateコマンドを活用し、定期的に依存関係を最新の状態に保つことを習慣にしましょう。ただし、大規模なアップデート前には十分なテストを行ってください。

これらのベストプラクティスを守ることで、Rustプロジェクトに外部クレートを効果的に活用し、安定した開発環境を構築できます。次に、依存関係管理の具体例を解説します。

クレートの依存関係管理の実践例

依存関係管理とは


依存関係管理とは、プロジェクトで使用する外部クレートやそのバージョンを適切にコントロールすることです。Rustでは、Cargoが強力な依存関係管理機能を提供しており、プロジェクトの安定性と互換性を保つために不可欠な作業です。

依存関係管理の基本


Rustプロジェクトの依存関係は、Cargo.tomlファイルに記述されます。このファイルでは、以下のように依存クレートを指定します：

[dependencies]
serde = "1.0"
tokio = { version = "1.0", features = ["full"] }
rand = "0.8"
  • 明示的なバージョン指定：serde = "1.0"のようにセマンティックバージョニングを用いることで、互換性のある範囲内で最新の修正を受け取ることができます。
  • 機能の選択：tokioの例のように、必要な機能だけを有効化することで依存関係を最適化できます。

依存関係の確認と監視

依存関係の一覧確認
cargo treeコマンドを使用して、依存関係の構造を可視化できます：

cargo tree

これにより、どのクレートが他のクレートに依存しているかを把握できます。

依存関係の更新
cargo updateコマンドを使用して、依存クレートを最新バージョンに更新します。ただし、大規模なアップデートは互換性の問題を引き起こす可能性があるため、事前にテストを実施してください。

依存関係の競合を解消する


複数のクレートが異なるバージョンの同じクレートを要求する場合、依存関係の競合が発生することがあります。このような場合には、Cargo.tomlでバージョンを固定するなどの方法で解消します。

バージョン固定の例

[dependencies]
serde = "=1.0.130"

依存関係の安全性を確保する

cargo auditの使用
cargo auditを用いることで、プロジェクトの依存クレートに既知の脆弱性が含まれていないかをチェックできます：

cargo install cargo-audit
cargo audit

ローカルミラーを使用する
セキュリティを強化するために、プロジェクトで使用するクレートを信頼できるローカルミラーで管理することも検討できます。

具体例：依存関係を効率的に管理するRustプロジェクト

以下の例は、serdeとtokioを使用したプロジェクトのCargo.toml設定と依存関係の管理を示しています：

[dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1.0", features = ["full"] }

[dev-dependencies]

rand = “0.8”

実装例
テスト環境ではrandを使ってランダム値を生成し、本番環境ではserdeとtokioを活用します：

#[cfg(test)]
mod tests {
    use rand::Rng;

    #[test]
    fn test_random_number() {
        let mut rng = rand::thread_rng();
        let num: u32 = rng.gen_range(1..=10);
        assert!(num >= 1 && num <= 10);
    }
}

依存関係管理の重要性


適切な依存関係管理は、以下のような利点をもたらします：

  • 安定性の向上：プロジェクトが互換性の問題なく動作します。
  • セキュリティの強化：脆弱性を持つ古いバージョンのクレートを排除できます。
  • メンテナンス性の向上：依存関係の構造が明確になるため、将来的な更新が容易になります。

Cargoを活用した依存関係管理の実践により、Rustプロジェクトの品質と安全性を向上させましょう。次は、セキュリティ考慮のためのクレート監査手法について説明します。

セキュリティ考慮のためのクレート監査手法

クレート監査の重要性


Rustエコシステムの豊富なクレートは、開発効率を高める一方で、セキュリティリスクを伴う可能性もあります。特に外部クレートを多用するプロジェクトでは、既知の脆弱性や不適切なコードが含まれる可能性を考慮し、事前に監査を行うことが重要です。

監査ツールの活用

cargo audit
cargo auditは、プロジェクトの依存関係に既知の脆弱性が含まれていないかをチェックするツールです。

  • インストール：
  cargo install cargo-audit
  • 使用例：
  cargo audit

このコマンドで、プロジェクトのCargo.lockを解析し、脆弱なクレートや更新が必要なクレートを一覧表示します。

cargo-deny
cargo-denyは、ライセンスの互換性、脆弱性、バージョン競合など、幅広い依存関係の問題を検出できるツールです。

  • インストール：
  cargo install cargo-deny
  • 使用例：
    設定ファイルを生成し、詳細な監査を実行します：
  cargo deny init
  cargo deny check

手動でのコードレビュー


ツールによる監査に加えて、重要なクレートについては手動でコードを確認することも検討すべきです。以下のポイントをチェックします：

  • 不審なコード：意図しないデータ送信やバックドアの存在。
  • メンテナンス状況：活発に更新されているかどうか。
  • セキュリティポリシー：公開されているセキュリティポリシーの有無。

依存関係の最小化


セキュリティリスクを減らすため、依存関係は必要最小限に絞りましょう。

  • 代替手段の検討：自分で簡単に実装可能な機能なら、外部クレートに頼らない。
  • 機能の限定：必要な機能だけを有効化することで、クレートの攻撃面を減らす。

安全なクレートの選択基準

  • ダウンロード数：crates.ioでのダウンロード数が多いほど信頼性が高い。
  • 更新履歴：最近更新されているかどうかを確認。
  • 公開リポジトリ：GitHubなどで公開されており、レビュー可能であること。

セキュリティ強化のための継続的な監視

定期的な監査
プロジェクトの進行中に新たな依存関係を追加した際には、都度監査を行いましょう。また、プロジェクト全体の監査も定期的に実施します。

脆弱性情報のチェック
Rustセキュリティアドバイザリーを定期的に確認し、使用しているクレートに関する最新の情報を得ます。

クレート監査のまとめ


クレート監査はプロジェクトのセキュリティを高めるために必要不可欠なプロセスです。ツールを活用した自動化、手動レビューによる補完、依存関係の最小化を組み合わせて、信頼性の高いプロジェクトを構築しましょう。次に、外部クレートをプロジェクトに導入する具体的な演習を解説します。

演習：Rustプロジェクトに外部クレートを導入する

目標


この演習では、Rustプロジェクトに外部クレートを追加し、そのクレートを使用して簡単な機能を実装します。例として、serde_jsonを使用してJSONデータのシリアライズとデシリアライズを行います。

演習手順

1. プロジェクトの作成


まず、新しいRustプロジェクトを作成します。

cargo new serde_example
cd serde_example

2. クレートの追加


プロジェクトのCargo.tomlに以下の依存関係を追加します：

[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

その後、依存関係をインストールします：

cargo build

3. データ型の定義


main.rsで以下のコードを追加し、JSONに変換可能な構造体を定義します：

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
struct User {
    id: u32,
    name: String,
    email: String,
}

4. JSONデータのシリアライズとデシリアライズ


次に、以下のコードを追加して、構造体をJSON文字列に変換し、また逆にJSON文字列を構造体に戻します：

fn main() {
    // データを構造体で定義
    let user = User {
        id: 1,
        name: "Alice".to_string(),
        email: "alice@example.com".to_string(),
    };

    // シリアライズ: 構造体 → JSON文字列
    let json_string = serde_json::to_string(&user).unwrap();
    println!("Serialized JSON: {}", json_string);

    // デシリアライズ: JSON文字列 → 構造体
    let deserialized_user: User = serde_json::from_str(&json_string).unwrap();
    println!("Deserialized User: {:?}", deserialized_user);
}

5. コードの実行


以下のコマンドでプログラムを実行し、結果を確認します：

cargo run

期待される出力例

Serialized JSON: {"id":1,"name":"Alice","email":"alice@example.com"}
Deserialized User: User { id: 1, name: "Alice", email: "alice@example.com" }

学習ポイント


この演習を通じて以下のスキルを習得できます：

  • serdeとserde_jsonクレートの基本的な使い方。
  • データのシリアライズ（Rust構造体 → JSON）とデシリアライズ（JSON → Rust構造体）。
  • Rustプロジェクトへの外部クレートの導入方法。

応用課題


さらに理解を深めるために、以下の応用課題に挑戦してみてください：

  1. 構造体に新しいフィールド（例：ageやis_active）を追加してみましょう。
  2. JSONファイルからデータを読み取る機能を実装してください。
  3. 配列やネストした構造体を使用して、より複雑なデータ構造を扱ってみてください。

この演習により、Rustプロジェクトでの外部クレートの活用に自信を持てるようになるでしょう。次に、この記事全体のまとめに移ります。

まとめ


本記事では、Rustでよく使用される外部クレートとして、serde、tokio、randを取り上げ、それぞれの特徴や活用例、導入手順を解説しました。また、外部クレートを安全かつ効果的に活用するためのベストプラクティスや依存関係管理、セキュリティ監査手法についても具体的に説明しました。

Rustの外部クレートを適切に活用することで、開発効率やコードの信頼性を大幅に向上させることができます。これらの知識をプロジェクトに応用し、効率的かつ安全な開発を進めていきましょう。

Rust
プログラミング Rust 外部クレート

コメント

コメントする

目次
  1. Rustの外部クレートとは
    1. 外部クレートの特徴
    2. 外部クレートの利用方法
    3. 外部クレートの利点
  2. データシリアライゼーションの標準：serde
    1. serdeとは
    2. serdeの主な特徴
    3. serdeのセットアップ方法
    4. serdeの活用例
    5. 用途とメリット
  3. 非同期プログラミングの主力：tokio
    1. tokioとは
    2. tokioの主な特徴
    3. tokioのセットアップ方法
    4. tokioの活用例
    5. 用途とメリット
  4. ランダム性の強力なサポート：rand
    1. randとは
    2. randの主な特徴
    3. randのセットアップ方法
    4. randの活用例
    5. 用途とメリット
    6. 注意点
  5. 外部クレートを活用するためのベストプラクティス
    1. 目的に合ったクレートを選定する
    2. 適切なバージョン管理
    3. クレートのドキュメントを活用する
    4. 依存関係の肥大化を防ぐ
    5. テスト環境での使用確認
    6. セキュリティを意識する
    7. 定期的な依存関係の更新
  6. クレートの依存関係管理の実践例
    1. 依存関係管理とは
    2. 依存関係管理の基本
    3. 依存関係の確認と監視
    4. 依存関係の競合を解消する
    5. 依存関係の安全性を確保する
    6. 具体例：依存関係を効率的に管理するRustプロジェクト
    7. 依存関係管理の重要性
  7. セキュリティ考慮のためのクレート監査手法
    1. クレート監査の重要性
    2. 監査ツールの活用
    3. 手動でのコードレビュー
    4. 依存関係の最小化
    5. 安全なクレートの選択基準
    6. セキュリティ強化のための継続的な監視
    7. クレート監査のまとめ
  8. 演習：Rustプロジェクトに外部クレートを導入する
    1. 目標
    2. 演習手順
    3. 学習ポイント
    4. 応用課題
  9. まとめ