Akasio is a simple HTTP server that redirects traffic based on a JSON redirect table. This is its Rust implementation.

Related tags


This page is inaccurate and is pending updates.

Akasio (Rust)


Akasio is a simple HTTP server that redirects traffic based on a JSON redirect table.

If you own a domain and wish to self-host a URL-shortening service, then this is the right tool for you.

Originally, Akasio is a backend server for website akas.io (akas stands for "also known as") written in Python and Flask. After rewriting the server with Golang, I decided to open-source it for anyone else that might be interested by it. It is both very easy to deploy and very easy to maintain, thanks to Golang's handy single-binary release (let's not talk about its size here).

Why Akasio

What can this be used for?

Personally, I find sending long URLs like https://gist.githubusercontent.com/k4yt3x/3b41a1a65f5d3087133e449793eb8858/raw to people pretty annoying, since you'll either have to copy and paste the whole URL or type the whole URL out. URL shorteners like Akasio solve this issue. All that's needed to be done to send such a long URL is just to create a new mapping in the redirect table (akas.io/z).

What are Akasio's benefits compared to services like bit.ly?

Akasio is self-hosted, and the redirect table is just a JSON file. This gives the users lots of flexibilities. The JSON file on the server can be symbolic-linked from a local workstation, updated by a front-end webpage, generated from a program, and so on.


This section covers Akasio's fundamental concepts, basic usages and setup guide.

Redirect Table

Akasio redirects incoming requests based on what's called a "redirect table". This table is essentially a JSON file with a simple source-to-target mapping. You can find an example akasio.json under the configs directory. By default, Akasio reads the redirect table from /etc/akasio.json.

    "/": "http://k4yt3x.com/akasio-rust",
    "/g": "https://github.com/k4yt3x",
    "/k4yt3x": "https://k4yt3x.com"

This example redirect table does the following mappings:

Taking the /g mapping for example, when a user visits https://yourwebsite.com/g, the user will be redirected to https://github.com/k4yt3x via a HTTP 301 (moved permanently) response.

URL Segments

When Akasio receives a request, it chops the request's path into segments, looks up the first segment against the redirect table, and returns the target URL + the rest of the segments joined with /.

For example, if the request URI is /segment1/segment2/segment3, the URI will be split into a string array with elements segment1, segment2, and segment3. Akasio will then lookup /segment1 within the redirect table and return redirected target URL + /segment2/segment3. If a / is not present at the end of the target URL, one will be appended automatically.

Continuing the example in the previous section, if the user visits https://yourwebsite.com/g/akasio-go, the user will be redirected to https://github.com/k4yt3x/akasio-go.

Website Setup

The recommended setup is to start Akasio as a service behind reverse proxy web server like Apache, Nginx or Caddy. You can find an example service file at configs/akasio.service.

A typical stand-alone setup process will look like the following.

  1. Build the akasio binary or download the akasio binary from releases (coming soon).
  2. Move the akasio binary to /usr/local/bin/akasio.
  3. Move the service file to /etc/systemd/system/akasio.service.
  4. Reload systemd with systemctl daemon-reload.
  5. Enable and start the service with systemctl enable --now akasio.
  6. Verify that the service has been started successfully via curl -v
  7. Configure front-end web server to reverse proxy to

Binary Usages

The binary's usage is as following. You can also invoke akasio -h to see the usages.

Akasio Redirector 0.1.0
A simple Rust program that redirects HTTP requests.

    akasio-rust [FLAGS] [OPTIONS]

    -d, --debug      enable debugging mode
    -h, --help       Prints help information
    -V, --version    Prints version information

    -b, --bind     binding IP address and port (IP:PORT)

The command below, for instance, launches Akasio, reads configurations from the file /etc/akasio.json, and serves domains akas.io and ffg.gg.

/usr/local/bin/akasio -r /etc/akasio.json -n akas.io -n ffg.gg

Running from Docker

Akasio is also available on Docker Hub. Below is an example how you can run Akasio with Docker. Be sure to create the redirect table and change the redirect table's path in the command below. You'll also need to change the server's hostname.

docker run -it -p 8000:8000 -v $PWD/akasio.json:/etc/akasio.json -h akasio --name akasio k4yt3x/akasio-go:1.1.1 -n akas.io

docker run -it \                                            # interactive
           -p 8000:8000 \                                   # bind container port to host's port 8000
           -v $PWD/akasio.json:/etc/akasio.json \           # bind mount host's akasio.json file under the current directory to container's /etc/akasio.json
           -h akasio \                                      # set container hostname akasio
           --name akasio \                                  # set container name akasio
           k4yt3x/akasio-go:1.1.1 \                         # container name
           -n akas.io                                       # listening hostnames

After spinning the container up, you can verify that it's running correctly by making a query with curl or any other tool of your preference.

Building From Source

The following commands will build Akasio binary at bin/akasio.

git clone https://github.com/k4yt3x/akasio-rust.git
cd akasio-go
cargo build

After building, you may also use sudo make install to install akasio to /usr/local/bin/akasio.

所謂的正確之物會隨人們各自的意志而遷移無常。| The so-called correctness will change with people's will.
Redirect Deno dependencies from semantic versions to the newest fitting version on deno.land/x

Deno Semver Redirect Redirect Deno dependencies from semantic versions to the newest fitting version on deno.land/x. See also this Deno Issue. How to

EdJoPaTo 5 Jun 1, 2021
REST-like API micro-framework for Rust. Works with Iron.

Table of Contents What is Rustless? Usage warning Basic Usage Complex example Mounting Parameters validation and coercion Use JSON Schema Query string

Rustless 604 Apr 27, 2021
A starter template for actix-web projects that feels very Django-esque. Avoid the boring stuff and move faster.

Jelly A.K.A, the actix-web starter you probably wish you had. This is provided as-is, and anyone is free to extend it or rework it as they desire - ju

SecretKeys 72 Jun 14, 2021
Simple http server in Rust (Windows/Mac/Linux)

How it looks like? Screenshot Command Line Arguments Simple HTTP(s) Server 0.6.1 USAGE: simple-http-server [FLAGS] [OPTIONS] [--] [root] FLAGS:

LinFeng Qian 463 Jun 15, 2021
A blazingly fast static web server with routing, templating, and security in a single binary you can set up with zero code. :zap::crab:

binserve ⚡ ?? A blazingly fast static web server with routing, templating, and security in a single binary you can set up with zero code. ?? UPDATE: N

Mufeed VH 452 Jun 14, 2021
Hidden parameters discovery suite

x8 Hidden parameters discovery suite written in Rust. How does it work Features Examples Send parameters via query Send parameters via body Custom tem

null 66 Jun 11, 2021
A lightweight web framework built on hyper, implemented in Rust language.

Sapper Sapper, a lightweight web framework, written in Rust. Sapper focuses on ergonomic usage and rapid development. It can work with stable Rust. Sa

Daogang Tang 615 May 27, 2021
Low level HTTP server library in Rust

tiny-http Documentation Tiny but strong HTTP server in Rust. Its main objectives are to be 100% compliant with the HTTP standard and to provide an eas

null 519 Jun 8, 2021
[OUTDATED] A light HTTP framework for Rust

Rustful A light HTTP framework for Rust, with REST-like features. The main purpose of Rustful is to create a simple, modular and non-intrusive foundat

Erik Hedvall 869 Jun 3, 2021
An Extensible, Concurrent Web Framework for Rust

Iron Extensible, Concurrency Focused Web Development in Rust. Response Timer Example Note: This example works with the current iron code in this repos

null 5.9k Jun 11, 2021
Rust templating with Handlebars

handlebars-rust Handlebars templating language implemented in Rust and for Rust. Handlebars-rust is the template engine that renders the official Rust

Ning Sun 687 Jun 15, 2021
Host These Things Please - a basic http server for hosting a folder fast and simply

http Host These Things Please - a basic HTTP server for hosting a folder fast and simply Selected features See the manpage for full list. Symlinks fol

thecoshman 302 Jun 14, 2021
Simple and fast web server

see Overview Simple and fast web server as a single executable with no extra dependencies required. Features Built with Tokio and Hyper TLS encryption

null 135 Jun 15, 2021
JSON Web Token implementation in Rust.

Frank JWT Implementation of JSON Web Tokens in Rust. Algorithms and features supported HS256 HS384 HS512 RS256 RS384 RS512 ES256 ES384 ES512 Sign Veri

Alex Maslakov 228 May 25, 2021