DEV Community: Finite Field

Outlineを使ってLinuxサーバー上にVPNサーバーを構築する方法

Finite Field — Tue, 17 Dec 2024 06:02:33 +0000

近年、プライバシー保護やセキュリティ強化、コンテンツフィルタリングの回避などの理由から、VPN(Virtual Private Network)を利用するケースが増えています。自前でVPNサーバーを立てることで、信頼性やプライバシー、コスト面でのメリットを得ることができます。

ここでは、Googleが支援するJigsaw社によって開発されたオープンソースツール「Outline」を使用して、一般的なLinuxサーバー上にVPNサーバーをセットアップする方法を紹介します。Outlineは、比較的簡潔な手順で安全なプロキシ(VPN)サーバーを構築できることで知られています。

なぜOutlineを使うのか？

シンプルなセットアップ：Outlineはコマンド一つでインストール・セットアップが可能な自動化ツールを提供しており、初心者でも扱いやすいです。
マルチプラットフォーム対応：クライアントはWindows、macOS、iOS、Android、Linuxなど幅広くサポートされており、どこからでも接続が可能です。
セキュアな通信：Shadowsocksプロキシをベースにした暗号化通信を行うため、高度なセキュリティが期待できます。

準備するもの

Linuxサーバー:
- 一般的なLinuxディストリビューション (Ubuntu, Debian, CentOSなど)でOK。
- パブリックIPアドレスを持つVPSやクラウドサーバーを用いるとよいでしょう。
- メモリ・CPU・ストレージは軽量構成で十分(1GB RAM程度、1 vCPU、10GB程度のストレージなど)。
サーバーへのアクセス権限：
- SSHでルートもしくはsudo権限を持つユーザーアクセスが必要。
クライアント側の準備：
- 後ほどOutlineクライアントアプリをインストールするため、接続したいデバイス(PC、スマホ、タブレットなど)が用意できる環境。

インストール手順

1. サーバー環境の初期設定

サーバーにSSHで接続します。以下はUbuntu系の場合の例です。

ssh username@your_server_ip

接続したら、サーバーパッケージの最新化を行います。

sudo apt update && sudo apt upgrade -y

2. Dockerのインストール

Outlineは内部的にDockerコンテナを使用します。そのため、Dockerが必要です。Ubuntu/Debianの場合:

sudo apt install -y apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/$(. /etc/os-release; echo "$ID")/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/$(. /etc/os-release; echo "$ID") $(lsb_release -cs) stable"
sudo apt update
sudo apt install -y docker-ce

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

sudo systemctl enable docker
sudo systemctl start docker
sudo docker run hello-world

Hello from Docker! と出れば成功です。

3. Outlineサーバーのインストールツールをダウンロード

Outline公式サイトのインストールガイドに従い、Linux版のOutline Manager CLI(サーバーインストーラー)を利用します。

curl -sSL https://raw.githubusercontent.com/Jigsaw-Code/outline-server/master/src/server_manager/install_scripts/install_server.sh | sudo bash

上記コマンドは、Outlineサーバーをインストールするためのスクリプトをダウンロードし、実行します。途中でDockerイメージがダウンロードされ、サーバーが設定されます。

4. サーバー管理情報の確認

インストール完了後、ターミナルに「管理用URL (Management URL)」や「アクセスキー (Access Key)」が表示されます。これらは後でクライアントツール(Outline Manager)でサーバーを管理する際に必要となりますので、必ずメモしておきましょう。

5. Outline Managerを使ってサーバーを管理

ローカルのPC(Windows/Mac/Linux)にOutline Managerアプリをインストールします。起動後、「Add a Server」や「サーバーを追加」ボタンを押し、先ほど取得した管理用URLを入力します。

これで、Outline ManagerからVPNサーバーにアクセスし、ユーザー(アクセスキー)を追加したり、接続情報を取得したりすることが可能になります。

6. クライアントアプリのセットアップ

接続したいクライアントデバイス(スマホやPC)にOutline Clientをインストールします。Outline Managerから取得したアクセスキー(接続キー)をクライアントアプリに読み込ませると、VPN接続が可能になります。

例：
1. Outline Clientをインストール
2. Managerから取得した「Access Key」をクリップボードコピー
3. Clientアプリの「+」ボタンや「Add Server」でキーをペースト
4. サーバーが追加されるので「Connect」ボタンで接続開始

接続後、Webブラウザで自分のIPアドレスをチェックすると、サーバーのIPアドレスで通信が行われていることが確認できます。

Outlineを使用すれば、わずか数ステップで安全なVPNサーバー(シャドーソックスプロキシ)を構築できます。自前サーバーによるVPN環境は、商用VPNに比べコントロール性やプライバシー面でのメリットが大きく、簡単な操作で世界中どこからでもセキュアなインターネット接続が可能になります。

レンタルサーバに関して、サーバーフィールドには様々な記事があります。どうぞご覧ください。また、Webサイト作成はどうぞ弊社（ファイナイトフィールド）にお任せください。

Dart's Sealed Classes: A Powerful Tool for Type Safety and Exhaustiveness

Finite Field — Sun, 15 Dec 2024 13:12:51 +0000

Dart, like many modern languages, is continually evolving to provide developers with better tools for writing robust and maintainable code. One feature that significantly enhances type safety and code clarity is the sealed class modifier. Introduced in Dart 3.0, sealed classes offer a way to restrict the inheritance hierarchy of a class, enabling powerful patterns and catching potential errors at compile time.

In this post, we'll delve into what sealed classes are, how they work, and why you should consider using them in your Dart projects.

What are Sealed Classes?

At their core, sealed classes are a mechanism for defining a class that can only be inherited by a specific, predefined set of subclasses. In essence, a sealed class creates a closed hierarchy. This is a powerful contrast to regular classes, which can be extended by any other class in your application.

Think of it like this: a regular class is a door that anyone can enter, while a sealed class is a door with a very specific list of allowed visitors.

Key characteristics of sealed classes:

Restricted Inheritance: Only the classes declared within the same library as the sealed class can extend or implement it.
Compile-Time Exhaustiveness: When working with a sealed class, the Dart compiler can enforce that your code handles all possible subclasses. This leads to more robust code and prevents potential runtime errors.
No Implementation: A sealed class does not have to have any implementation. It is simply a marker class.

Syntax of Sealed Classes

Declaring a sealed class is straightforward. You simply add the sealed keyword before the class keyword:

sealed class Shape {}

Now, let's define some allowed subclasses within the same library (usually in the same file):

sealed class Shape {}

class Circle extends Shape {
  final double radius;
  Circle(this.radius);
}

class Square extends Shape {
  final double side;
  Square(this.side);
}

class Triangle extends Shape {
  final double base;
  final double height;
  Triangle(this.base, this.height);
}

// This won't compile because it's in a different file
//class Rectangle extends Shape {}

In this example, Shape is our sealed class, and Circle, Square, and Triangle are the only classes that can inherit from it. If you try to create another class in a different file that extends Shape, you'll get a compile-time error.

The Power of Exhaustiveness

The real magic of sealed classes lies in the compile-time exhaustiveness check. Dart can use the information about the limited number of subclasses of a sealed class to ensure that your switch statements or if/else chains cover all the possible cases.

Here's how that looks:

sealed class Shape {}

class Circle extends Shape {
  final double radius;
  Circle(this.radius);
}

class Square extends Shape {
  final double side;
  Square(this.side);
}

class Triangle extends Shape {
  final double base;
  final double height;
  Triangle(this.base, this.height);
}

double calculateArea(Shape shape) {
  switch (shape) {
    case Circle():
      return 3.14 * shape.radius * shape.radius;
    case Square():
      return shape.side * shape.side;
    case Triangle():
      return 0.5 * shape.base * shape.height;
  }
}

In the calculateArea function, if you were to forget one of the cases (e.g., the Triangle case), the Dart compiler would throw an error. This immediately points out that your code is incomplete and helps prevent potential runtime bugs. This is why sealed classes are particularly useful in combination with pattern matching.

With regular classes, if you add a new subclass, your old code may break silently at runtime. The compiler will not give a warning because it doesn't know that the subclasses are closed. But, in the case of sealed classes, the compiler gives a compile-time error forcing you to address it immediately, leading to more robust and maintainable code.

Use Cases for Sealed Classes

Sealed classes are a valuable tool in several scenarios:

State Management: When managing application state, you often have a distinct set of states that an object can be in. Using a sealed class to represent the possible states ensures your code handles them all correctly. This is particularly helpful when you are dealing with asynchronous operations. For example:
```
sealed class DataState {}
class Loading extends DataState{}
class Loaded extends DataState{
  final dynamic data;
  Loaded(this.data);
}
class Error extends DataState {
  final String errorMessage;
  Error(this.errorMessage);
}
```
Algebraic Data Types (ADTs): Sealed classes excel at modeling ADTs, where data can take on a finite set of forms. This enables you to express your domain logic very clearly and have the compiler enforce that your code correctly handles all the possible cases.
Representing Events: In event-driven architectures, sealed classes can represent different event types. This allows you to build event handlers that are guaranteed to cover all possible events.
Exhaustive switch cases: The compiler enforces that you have handled all the possible type with in switch statement.

Benefits of Using Sealed Classes

Enhanced Type Safety: Compile-time checks help you catch missing cases, reducing runtime errors.
Improved Code Maintainability: The compiler forces you to revisit and update the relevant code when new subclasses are added, preventing your application from breaking silently.
Clearer Domain Modeling: Sealed classes help you precisely express the structure of your data, making it more understandable.

Conclusion

The sealed class modifier is a significant addition to Dart, bringing compile-time exhaustiveness and improved type safety. They're a valuable tool to add to your development arsenal, particularly when dealing with state, ADTs, events, or any situation where you have a well-defined set of types that you need to handle exhaustively.

By adopting sealed classes, you can write more robust, maintainable, and less error-prone Dart code. So, next time you're working on a Flutter or Dart project, consider if a sealed class could help streamline your logic. At Finite Field, we understand the power of cutting-edge features like sealed classes. As a dedicated app development company, we leverage these kinds of tools, along with deep expertise in Flutter and Dart, to craft innovative and high-quality mobile applications for our clients. If you're looking for a partner to bring your app idea to life with a focus on maintainable and scalable code, we'd love to hear from you.

Level Up Your Flutter App: Mastering the SearchBar Widget

Finite Field — Sun, 15 Dec 2024 13:11:13 +0000

In today's apps, users expect seamless search functionality. Whether it's finding a specific product, locating a contact, or sifting through a list of articles, a good search experience is crucial. Luckily, Flutter provides the SearchBar widget to make implementing search functionality a breeze.

This post will guide you through everything you need to know to effectively use the SearchBar in your Flutter applications. We'll cover basic setup, handling user input, displaying results, and some common customization options.

Let's dive in!

Getting Started: The Basic Setup

Before we get to the search logic, we need to set up our SearchBar widget within our Flutter UI. Here's the most basic implementation:

import 'package:flutter/material.dart';

class SearchExample extends StatefulWidget {
  @override
  _SearchExampleState createState() => _SearchExampleState();
}

class _SearchExampleState extends State<SearchExample> {
  String _searchText = '';

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Search Example'),
      ),
      body: Padding(
        padding: const EdgeInsets.all(16.0),
        child: SearchBar(
          hintText: 'Search here...',
          onChanged: (text) {
            setState(() {
              _searchText = text;
            });
            // You'll add search logic here later
          },
        ),
      ),
    );
  }
}

What's happening here?

SearchBar Widget: We've added the SearchBar widget directly into our widget tree, which takes care of the visual layout of the search bar.
hintText: This provides a helpful placeholder text inside the search bar.
onChanged Callback: This function is triggered every time the user types or deletes something in the search bar. This is where our search logic will live!
_searchText Variable: We use a StatefulWidget to manage the search text as the user types.
setState: We update the _searchText using setState, which triggers a rebuild and shows the updated value.

If you run this code, you'll have a basic working search bar that updates the _searchText variable!

Adding Search Logic

Now, let's make the search bar actually do something. We'll assume we have a simple list of items that we want to search through. Here's how we can update the code:

import 'package:flutter/material.dart';

class SearchExample extends StatefulWidget {
  @override
  _SearchExampleState createState() => _SearchExampleState();
}

class _SearchExampleState extends State<SearchExample> {
  String _searchText = '';
  List<String> _allNames = ['Apple', 'Banana', 'Cherry', 'Date', 'Elderberry', 'Fig']; //Example Data
  List<String> _filteredNames = [];

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Search Example'),
      ),
      body: Padding(
        padding: const EdgeInsets.all(16.0),
        child: Column(
          children: [
            SearchBar(
              hintText: 'Search Names...',
              onChanged: (text) {
                setState(() {
                    _searchText = text;
                  if (text.isNotEmpty) {
                   _filteredNames = _allNames.where((name) =>
                          name.toLowerCase().contains(text.toLowerCase()))
                            .toList();
                  } else {
                    _filteredNames = [];
                  }

                });
              },
            ),
            SizedBox(height: 16),
            Expanded(
              child: ListView.builder(
                  itemCount: _searchText.isEmpty? _allNames.length : _filteredNames.length,
                  itemBuilder: (context, index) {
                  return ListTile(
                    title: Text(_searchText.isEmpty? _allNames[index] : _filteredNames[index]),
                  );
                  }
              ),
            ),
          ],
        ),
      ),
    );
  }
}

Changes:

_allNames: A sample list of strings we'll be searching through.
_filteredNames: This list will store the search results.
Search Logic: Inside the onChanged callback:
- We check if the search text is not empty. If it is not empty we use the .where method to filter the _allNames based on a substring match (case-insensitive).
- If the search text is empty we set the _filteredNames to empty list.
ListView.builder Now we display either all names or the filtered name depending on the state of the search text.

Now, as you type in the search bar, the list of names will update in real-time to show only the matching results.

Customizing the `SearchBar`

The SearchBar widget offers several ways to customize its appearance and behavior. Here are a few of the most common:

controller: You can use a TextEditingController to control the input of the search bar. This is useful if you need to pre-populate the search bar or programmatically clear it.
leading and trailing: Add widgets (such as Icons) before and after the input field.
backgroundColor and other styling properties: Use these to change the look and feel of the search bar.

Here's a quick example of using a leading icon and changing the background color:

SearchBar(
  hintText: 'Search...',
  backgroundColor: MaterialStateProperty.all(Colors.grey[200]),
  leading: Icon(Icons.search),
  onChanged: (text) {
    // ...
  },
);

Beyond the Basics

This blog post provides a foundation for working with the SearchBar widget. Here are some ideas for taking your search functionality further:

Debouncing: Prevent your search logic from running on every single keystroke by using a debouncer. This can significantly improve performance.
API Integration: Fetch search results from an API instead of a local list.
Loading Indicators: Provide feedback to the user while results are loading from an API.
Search Suggestions: Offer suggestions as the user types to help them find what they are looking for quickly.

Conclusion

The SearchBar widget is a powerful and flexible tool for building search functionality in Flutter. By following the techniques outlined in this blog post, you'll be well on your way to crafting excellent user experiences in your Flutter applications.

At Finite Field, we understand the power of cutting-edge features like SearchBar. As a dedicated app development company, we leverage these kinds of tools, along with deep expertise in Flutter and Dart, to craft innovative and high-quality mobile applications for our clients. If you're looking for a partner to bring your app idea to life with a focus on maintainable and scalable code, we'd love to hear from you.

DEV Community: Finite Field

Outlineを使ってLinuxサーバー上にVPNサーバーを構築する方法

なぜOutlineを使うのか？

準備するもの

インストール手順

1. サーバー環境の初期設定

2. Dockerのインストール

3. Outlineサーバーのインストールツールをダウンロード

4. サーバー管理情報の確認

5. Outline Managerを使ってサーバーを管理

6. クライアントアプリのセットアップ

Dart's Sealed Classes: A Powerful Tool for Type Safety and Exhaustiveness

What are Sealed Classes?

Syntax of Sealed Classes

The Power of Exhaustiveness

Use Cases for Sealed Classes

Benefits of Using Sealed Classes

Conclusion

Level Up Your Flutter App: Mastering the SearchBar Widget

Getting Started: The Basic Setup

Adding Search Logic

Customizing the SearchBar

Beyond the Basics

Conclusion

Customizing the `SearchBar`