DEV Community: Wahyu Rudiyan Saputra

Build Auth Service using Axum and PASETO

Wahyu Rudiyan Saputra — Fri, 31 Jan 2025 15:09:38 +0000

Overview

Auth service is a most crucial service in a Web Application. Auth consist of two roles, Authentication and Authorization. Authentication act as user identity verificatory, and Authorization to grant user to access certain resources according to the Access Levels.

PASETO

The Auth Creds Data will signed into Token using JavaScript Object Signing Encryption (JOSE), and the new and more secure than JSON Web Token signing algorithm is PASETO. PASETO stands for Platform Agnostic Security Token. If you do not familiar with this algorithm, I really recommend you to visit this page and read the references: https://paseto.io/.

PASETO provides two type of signing encryption, for Local and Public usage. If you want to use token for internal microservice communication, use Local signing. Or use Public to share asymmetric key to share with public service communication such as 3rd Party Services.

Service Architecture

The architecture Claiming Local Token like the following image.

Implementation to Claim Public Token need ED25519 Key Pairs, so prepare it first. The architecture may like this.

PASETORS Crate

This library recommend by official website PASETO (https://paseto.io). Before we start to implement PASETO in Rust, we need to know constraints about this library (crate).

PASETORS use compact ED25519 algorithm crate that generate 32-bytes PEM file to generate key pairs. Then, this file set as reference to generate secret-key and public-key. Those keys will use as Asymmetric Key.

To implement local token, you can use 32-bytes (32 characters) as secret key.

Initialization and Routes

In main.rs file in src/, put all configuration code and initialize HTTP server.

// main.rs

use api::router::Routes;
use axum::Router;
use dotenv::dotenv;
use log::info;
use service::{auth_interface::AuthService, paseto_service::PasetoService};
use std::{env, fs, sync::Arc};

mod api;
mod models;
mod service;

#[tokio::main]
async fn main() {
    // Init some dependencies
    dotenv().ok();
    env_logger::init();

    let mut app_port = env::var("APP_PORT").unwrap();
    app_port = if app_port == "" {
        "3000".to_string()
    } else {
        app_port
    };

    // Just for example, not recommend for production
    let cert_path = env::var("CERTIFICATE_PATH").expect("Certificate path cannot empty");
    let pem = fs::read_to_string(cert_path).expect("Unable to read ed25519_key.pem");
    let local_secret = env::var("PASETO_LOCAL_SECRET").expect("Envar: local secret cannot empty");
    let hmac_secret = env::var("PASETO_HMAC_SECRET").expect("Envar: hmac secret cannot empty");

    // Init auth service as dependency for controller that passing over layer
    let paseto_service = PasetoService::new(pem, local_secret, hmac_secret);

    // Init REST Service
    let app_host = format!("0.0.0.0:{app_port}");
    let routes = Routes::new(paseto_service);
    let app = Router::new().nest("/api", routes.router());
    let listener = tokio::net::TcpListener::bind(app_host.clone())
        .await
        .unwrap();

    log::info!("🚀 Server running at host: {app_host}");
    if let Err(e) = axum::serve(listener, app.into_make_service()).await {
        panic!("Unable to run server, error occur: {}", e);
    }
}

Now, see at the beginning of main() function, #[tokio::main] macro is set to make main() running with asynchronous runtime.

For API routes, all of them written as module and placed in src/api/router.rs.

// src/api/router.rs

use super::controller::auth_controller::{
    claim_local_token, claim_public_token, verify_local_token, verify_public_token,
};
use crate::service::auth_interface::AuthService;
use axum::{routing::post, Extension, Router};

pub struct Routes<T: AuthService + Clone> {
    auth_service: T,
}

impl <T: AuthService + Clone> Routes<T> {
    pub fn new(paseto_service: T) -> Self {
        Routes {
            auth_service: paseto_service,
        }
    }

    pub fn router(&self) -> Router {
        Router::new().nest(
            "/auth/token",
            Router::new()
                .route("/local/claim", post(claim_local_token::<T>))
                .route("/local/verify", post(verify_local_token::<T>))
                .route("/public/claim", post(claim_public_token::<T>))
                .route("/public/verify", post(verify_public_token::<T>))
                .layer(Extension(self.auth_service.clone())),
        )
    }
}

Controller and Service Layer

Controller will handle any request and act as 'bridge' between HTTP Server and Service Layer. Controller will perform JSON Request Body Parsing and provide Extension for Dependency Injection. In term of Dependency Injection, this means the Service Layer will inject into Controller, it make Controller able to access the AuthService trait. The Controller and Service Layer look like this.

// The Controller
// src/api/controller/auth_controller.rs

use crate::{
    models::{
        dto::auth::{
            PasetoClaimRequest, PasetoClaimResponse, PasetoVerifyRequest, PasetoVerifyResponse,
        },
        entities::auth::{PasetoToken, UserData},
    },
    service::auth_interface::AuthService,
};
use axum::{http::StatusCode, response::IntoResponse, Extension, Json};
use std::sync::Arc;

pub async fn claim_local_token<T:AuthService>(
    Extension(state): Extension<T>,
    Json(body): Json<PasetoClaimRequest>,
) -> impl IntoResponse {
    let user_data = UserData { user: body.user };
    let claim_svc = state.claim_local_token(user_data);
    match claim_svc {
        Ok(result) => {
            log::info!("Local token claimed...");
            let response = PasetoClaimResponse::success(result);
            (StatusCode::OK, Json(response))
        }

        Err(e) => {
            log::error!("Error occur - claim local token: {}", e.to_string());
            let response = PasetoClaimResponse::failure("unable to claim token".to_string());
            (StatusCode::INTERNAL_SERVER_ERROR, Json(response))
        }
    }
}

pub async fn verify_local_token<T:AuthService>(
    Extension(state): Extension<T>,
    Json(body): Json<PasetoVerifyRequest>,
) -> impl IntoResponse {
    let token = PasetoToken {
        token: body.token,
        expired: body.expired,
    };
    let verified = state.verify_local_token(token);
    match verified {
        Ok(data) => {
            log::info!("Local token verified...");
            let response = PasetoVerifyResponse::success(data);
            (StatusCode::OK, Json(response))
        }

        Err(e) => {
            log::error!("Error occur - verify local token: {}", e.to_string());
            let response =
                PasetoVerifyResponse::failure("invalid local token, user unauthorized".to_string());
            (StatusCode::UNAUTHORIZED, Json(response))
        }
    }
}

pub async fn claim_public_token<T:AuthService>(
    Extension(state): Extension<T>,
    Json(body): Json<PasetoClaimRequest>,
) -> impl IntoResponse {
    let user_data = UserData { user: body.user };
    let claim_svc = state.claim_public_token(user_data);
    match claim_svc {
        Ok(result) => {
            log::info!("Public token claimed...");
            let response = PasetoClaimResponse::success(result);
            (StatusCode::OK, Json(response))
        }

        Err(e) => {
            log::error!("Error occur - claim public token: {}", e.to_string());
            let response = PasetoClaimResponse::failure("unable to claim public token".to_string());
            (StatusCode::INTERNAL_SERVER_ERROR, Json(response))
        }
    }
}

pub async fn verify_public_token<T:AuthService>(
    Extension(state): Extension<T>,
    Json(body): Json<PasetoVerifyRequest>,
) -> impl IntoResponse {
    let token = PasetoToken {
        token: body.token,
        expired: body.expired,
    };
    let verified = state.verify_public_token(token);
    match verified {
        Ok(data) => {
            log::info!("Public token verified...");
            let response = PasetoVerifyResponse::success(data);
            (StatusCode::OK, Json(response))
        }

        Err(e) => {
            log::error!("Error occur - verify public token: {}", e.to_string());
            let response = PasetoVerifyResponse::failure(
                "invalid public token, user unauthorized".to_string(),
            );
            (StatusCode::UNAUTHORIZED, Json(response))
        }
    }
}

Next, the following code is trait of AuthService. Trait act as interface for modularity.

// src/service/auth_interface.rs

use crate::models::{
    dto::auth::PasetoVerifiedData,
    entities::auth::{PasetoToken, UserData},
};
use async_trait::async_trait;
use axum::Error;

#[async_trait]
pub trait AuthService: Send + Sync + 'static {
    fn claim_local_token(&self, user: UserData) -> Result<PasetoToken, Error>;
    fn verify_local_token(&self, token: PasetoToken) -> Result<PasetoVerifiedData, Error>;
    fn claim_public_token(&self, user: UserData) -> Result<PasetoToken, Error>;
    fn verify_public_token(&self, body: PasetoToken) -> Result<PasetoVerifiedData, Error>;
}

Trait just for abstraction of concrete function. The implementation of trait linked by a struct. I use new() function as constructor to do that. The concrete function is core logic for PASETO Auth Service. So, the code should be like this.

// src/service/paseto_service.rs

use crate::models::{
    dto::auth::PasetoVerifiedData,
    entities::auth::{PasetoToken, PayloadClaim, UserData},
};
use async_trait::async_trait;
use axum::Error;
use ed25519_compact::SecretKey;
use pasetors::{
    claims::{Claims, ClaimsValidationRules},
    keys::{AsymmetricPublicKey, AsymmetricSecretKey, SymmetricKey},
    local, public,
    token::UntrustedToken,
    version4::V4,
    Local, Public,
};

use super::auth_interface::AuthService;

#[derive(Clone)]
pub struct PasetoService {
    secret_key: Vec<u8>,
    public_key: Vec<u8>,
    local_secret: String,
    hmac_secret: String,
}

impl PasetoService {
    pub fn new(pem: String, local_secret: String, hmac_secret: String) -> Self {
        let sk = SecretKey::from_pem(pem.as_str()).unwrap();
        let pk = sk.public_key();
        PasetoService {
            secret_key: sk.as_ref().to_vec(),
            public_key: pk.as_ref().to_vec(),
            local_secret: local_secret,
            hmac_secret: hmac_secret,
        }
    }
}

#[async_trait]
impl AuthService for PasetoService {
    fn claim_local_token(&self, user: UserData) -> Result<PasetoToken, Error> {
        let now = chrono::Utc::now();
        let expired_at = now + chrono::Duration::hours(12);

        // claim data
        let mut claims = Claims::new().unwrap();
        claims.expiration(&expired_at.to_rfc3339()).unwrap();
        claims
            .add_additional("user_data", serde_json::json!(user))
            .unwrap();

        if self.local_secret.len() != 32 {
            return Err(Error::new("invalid secret key length, must 32 bytes"));
        }

        let symmetric_key = SymmetricKey::<V4>::from(self.local_secret.as_bytes()).unwrap();
        let encrypted = local::encrypt(
            &symmetric_key,
            &claims,
            None,
            Some(self.hmac_secret.as_bytes()),
        );
        match encrypted {
            Ok(token) => {
                let data = PasetoToken {
                    token: token,
                    expired: expired_at.to_rfc3339(),
                };

                return Ok(data);
            }
            Err(err) => {
                return Err(Error::new(format!(
                    "error occur when encrypting token: {}",
                    err.to_string()
                )));
            }
        }
    }

    fn verify_local_token(&self, body: PasetoToken) -> Result<PasetoVerifiedData, Error> {
        let is_expired = body.is_expired();
        if is_expired {
            return Err(Error::new("expired token cannot claimed"));
        }

        if self.local_secret.len() != 32 {
            return Err(Error::new("invalid secret key length, must 32 bytes"));
        }

        let validation_rules = ClaimsValidationRules::new();
        let untrusted_token = UntrustedToken::<Local, V4>::try_from(&body.token).unwrap();

        let symetric_key = SymmetricKey::<V4>::from(self.local_secret.as_bytes()).unwrap();
        let trusted_token = local::decrypt(
            &symetric_key,
            &untrusted_token,
            &validation_rules,
            None,
            Some(self.hmac_secret.as_bytes()),
        )
        .unwrap();

        let payload = trusted_token.payload_claims().unwrap().to_string().unwrap();
        let p = serde_json::from_str::<PayloadClaim>(&payload).unwrap();
        let verified_data = PasetoVerifiedData::new(p.user_data.user, true);

        Ok(verified_data)
    }

    fn claim_public_token(&self, user: UserData) -> Result<PasetoToken, Error> {
        let now = chrono::Utc::now();
        let expired_at = now + chrono::Duration::hours(12);

        // claim data
        let mut claims = Claims::new().unwrap();
        claims.expiration(&expired_at.to_rfc3339()).unwrap();
        claims
            .add_additional("user_data", serde_json::json!(user))
            .unwrap();

        let pvt_key = AsymmetricSecretKey::<V4>::from(&self.secret_key).unwrap();
        let encrypted = public::sign(&pvt_key, &claims, None, Some(self.hmac_secret.as_bytes()));
        match encrypted {
            Ok(token) => {
                let data = PasetoToken {
                    token: token,
                    expired: expired_at.to_rfc3339(),
                };

                return Ok(data);
            }
            Err(err) => {
                return Err(Error::new(format!(
                    "error occur when encrypting token: {}",
                    err.to_string()
                )));
            }
        }
    }

    fn verify_public_token(&self, body: PasetoToken) -> Result<PasetoVerifiedData, Error> {
        let is_expired = body.is_expired();
        if is_expired {
            return Err(Error::new("expired token cannot claimed"));
        }

        let validation_rules = ClaimsValidationRules::new();
        let untrusted_token = UntrustedToken::<Public, V4>::try_from(&body.token).unwrap();

        let pub_key = AsymmetricPublicKey::<V4>::from(&self.public_key).unwrap();
        let trusted_token = public::verify(
            &pub_key,
            &untrusted_token,
            &validation_rules,
            None,
            Some(self.hmac_secret.as_bytes()),
        )
        .unwrap();

        let payload = trusted_token.payload_claims().unwrap().to_string().unwrap();
        let p = serde_json::from_str::<PayloadClaim>(&payload).unwrap();
        let verified_data = PasetoVerifiedData::new(p.user_data.user, true);

        Ok(verified_data)
    }
}

Containerization and Running the App

In modern web application deployment, containerization is a must. We need Docker to make an image for this application. I also build this application using Multi-Stage strategy.

FROM rust:1.84 AS builder
WORKDIR /app
COPY . .
RUN cargo build --release

FROM debian:latest
WORKDIR /app
COPY --from=builder /app/target/release/axum-auth /app
RUN --mount=type=secret,id=paseto_private_key,target=/run/secrets/private_key.pem
RUN chmod +x axum-auth
CMD ["./axum-auth"]

Please, pay attention with the base image that I use for application image. I choose debian:latest to solve GLIBC incompatibility issue.

You don't need to run to make Docker Image separately with running application using Docker Compose. Define build and creating image within docker-compose.yaml.

services:
  axum:
    container_name: axum-auth-service
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    secrets:
      - private_key
    environment:
      - RUST_LOG=info
      - APP_PORT=3000
      - CERTIFICATE_PATH=/run/secrets/private_key
      - PASETO_LOCAL_SECRET=#S3cretK3Y!ThisK3yMu5tBe32Bytes!
      - PASETO_HMAC_SECRET=f3f8a71c69bdf338c447029f0ff51887fc7e57c49b77c8b5cab001c986393dcc
    volumes:
      - ./axum-auth:/app/data

secrets:
  private_key:
    file: ./ed25519_key.pem # this file generate by me in my local machine

Build the container image with run this command:

docker compose up --build

Closing

This implementation is not for production purpose. I intend to write this code just for my portfolio sample to proof my Rust skill. There are notes if you want to implement this code on your production level:

Take care with error handling, I use too many unwrap() to get the return value directly. If an error occur, it will panic.
The secrets and config file. You have to set all secret with docker secrets (or Kubernetes secrets or Vault).
Use Dynamic Dispatch for Thread Safety when you implement Dependency Injection. I am using Static Dispatch just for example.

For more details of this code, please visit my repository. Support me with like in this post and start on my repo.

Github Repo: https://github.com/wahyurudiyan/axum-auth/

[Indonesia] Tracer: Open Telemetry, Golang, and Jaeger Simple Implementation

Wahyu Rudiyan Saputra — Thu, 16 Jan 2025 05:40:41 +0000

Tracer

Tracer merupakan bagian dari Observability yang mengambil peran penting dalam implementasi Microservices Architecture dan memberikan gambaran 'Jejak' dari proses yang berjalan di sebuah logic aplikasi.

Sederhananya, pada Webservice, Tracer akan memberikan gambaran mengenai seberapa lama waktu eksekusi dari suatu logic dengan memancarkan sinyal Trace. Nantinya, Tracer ini akan dapat divisualisasikan dan dilihat dalam bentuk nested span setelah memancarkan sinyal melalui Exporter ke Collector. [OpenTelemetry: Traces]

OpenTelemetry

Untuk dapat memancarkan sinyal Traces yang nantinya dapat di Collect oleh Collector, Webservice membutuhkan OpenTelemetry sebagai pustaka yang telah menjadi standar protokol Observability yang biasa disebut OpenTelemetry Protocol (OTLP). [OpenTelemetry: Language - Go]

Jaeger

Visualisasi dari Traces signal sangat dibutuhkan untuk memberikan gambaran dari proses apa saja yang terjadi pada Webservice. Jaeger merupakan Open-Source platform yang telah mendukung OTLP dengan memanfaat protokol komunikasi HTTP atau gRPC. [Jaeger]

Implementasi di Golang

Implementasi Tracer pada bahasa pemrograman Golang akan menerapkan kasus sederhana dimana Webservice hanya akan memberikan balikan data dengan durasi respons yang berbeda. Pustaka yang akan digunakan yaitu:

Chi: HTTP Framework
OpenTelemetry: Telemetry Signaling

Setup OpenTelemetry sebagai modul Telemetry

Implementasi modul Telemetry di direktori pkg/telemetry/telemetry.go:

package telemetry

import (
    "context"
    "errors"
    "time"

    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
    "go.opentelemetry.io/otel/sdk/resource"
    "go.opentelemetry.io/otel/sdk/trace"
)

// enumeration constant for which protocol used
const (
    HTTP uint8 = iota
    GRPC
)

// setup client to connect web-service with Jaeger
func SetupTraceClient(ctx context.Context, protocol uint8, endpoint string) otlptrace.Client {
    switch protocol {
    case GRPC:
        return otlptracegrpc.NewClient(otlptracegrpc.WithEndpoint(endpoint), otlptracegrpc.WithInsecure(), otlptracegrpc.WithCompressor("gzip"))
    default:
        return otlptracehttp.NewClient(otlptracehttp.WithEndpoint(endpoint), otlptracehttp.WithInsecure(), otlptracehttp.WithCompression(otlptracehttp.NoCompression))
    }
}

func setupTraceProvider(ctx context.Context, traceClient otlptrace.Client) (*trace.TracerProvider, error) {
    // set resource
    res, err := resource.New(
        ctx,
        resource.WithFromEnv(),
    )
    if err != nil {
        return nil, err
    }

    // init trace exporter
    traceExporter, err := otlptrace.New(ctx, traceClient)
    if err != nil {
        return nil, err
    }

    // init trace exporter
    traceProvider := trace.NewTracerProvider(
        trace.WithBatcher(
            traceExporter,
            trace.WithBatchTimeout(time.Duration(time.Second*3)),
        ),
        trace.WithResource(res), // Discover and provide attributes from OTEL_RESOURCE_ATTRIBUTES and OTEL_SERVICE_NAME environment variables.
    )

    return traceProvider, nil
}

func SetupTelemetrySDK(ctx context.Context, traceClient otlptrace.Client) (func(context.Context) error, error) {
    var err error
    var shutdownFuncs []func(context.Context) error

    shutdown := func(ctx context.Context) error {
        var err error
        for _, fn := range shutdownFuncs {
            err = errors.Join(err, fn(ctx))
        }
        shutdownFuncs = nil
        return err
    }

    handleErr := func(inErr error) {
        err = errors.Join(inErr, shutdown(ctx))
    }

    traceProvider, err := setupTraceProvider(ctx, traceClient)
    if err != nil {
        handleErr(err)
        return shutdown, err
    }

    shutdownFuncs = append(shutdownFuncs, traceProvider.Shutdown)
    otel.SetTracerProvider(traceProvider)

    return shutdown, nil
}

Kemudian, setup konfigurasi Telemetry di main function main.go:

package main

import (
    "context"
    "fmt"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"

    "github.com/go-chi/chi/v5"
    "github.com/wahyurudiyan/medium/otel-jaeger/config"
    "github.com/wahyurudiyan/medium/otel-jaeger/pkg/telemetry"
    "github.com/wahyurudiyan/medium/otel-jaeger/router"
)

func SetupTelemetry(ctx context.Context, config *config.Config) (func(context.Context) error, error) {
    otlpCli := telemetry.SetupTraceClient(ctx, telemetry.GRPC, config.JaegerGRPCEndpoint)
    shutdownFn, err := telemetry.SetupTelemetrySDK(ctx, otlpCli)
    return shutdownFn, err
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    cfg := config.Get()

    shutdownFn, err := SetupTelemetry(ctx, cfg)
    if err != nil {
        shutdownFn(ctx)
        panic(err)
    }

    r := chi.NewRouter()
    r.Route("/api", func(r chi.Router) {
        router.Router(r)
    })

    srv := http.Server{
        Addr:    "0.0.0.0:8080",
        Handler: r,
    }
    go func() {
        fmt.Println("Server running at port:", srv.Addr)
        if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            fmt.Printf("listen: %s\n", err)
        }
    }()

    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit

    defer shutdownFn(ctx)
    fmt.Println("Server is shutting down...")
    if err := srv.Shutdown(context.Background()); err != nil {
        fmt.Println("Server forced to shutdown:", err)
    }

    fmt.Println("Server exiting")
}

Penggunaan Tracer di handler pada file router/router.go untuk dapat memancarkan sinyal Traces:

package router

import (
    "encoding/json"
    "net/http"
    "time"

    "github.com/go-chi/chi/v5"
    "github.com/wahyurudiyan/medium/otel-jaeger/pkg/random"
    "go.opentelemetry.io/otel"
)

var (
    tracer = otel.Tracer("WebServer-Otel-Jaeger")
)

func getUserHandler(w http.ResponseWriter, r *http.Request) {
    _, span := tracer.Start(r.Context(), "GetUser")
    defer span.End()

    user := struct {
        Name     string
        Email    string
        Password string
    }{
        Name:     "John Doe",
        Email:    "john@email.com",
        Password: "Super5ecr3t!",
    }
    blob, _ := json.Marshal(&user)

    sleepDuration := time.Duration(time.Millisecond * time.Duration(random.GenerateRandNum()))
    time.Sleep(sleepDuration)

    w.Header().Add("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    w.Write(blob)
}

func Router(router chi.Router) {
    router.Get("/user", getUserHandler)
}

Deployment

Konfigurasi docker untuk Build Webservice ini, memanfaatkan mekanisme Multi-Stage Build Image pada Dockerfile:

FROM golang:1.23.4 AS build
WORKDIR /src
COPY . .
RUN go get -v
RUN CGO_ENABLED=0 go build -o /bin/service .

FROM alpine:latest
WORKDIR /app
COPY --from=build /bin/service /bin/service
CMD ["/bin/service"]

Selanjutnya, build image akan dilakukan melalui file docker-compose.yaml dengan konfigurasi berikut:

services:
  web-service:
    container_name: service
    build:
      context: .
      dockerfile: Dockerfile
    environment:
      OTEL_SERVICE_NAME: service-otel-jaeger
      JAEGER_GRPC_ENDPOINT: jaeger:4317
    entrypoint: ["service"]
    ports:
      - 8080:8080

  jaeger:
    container_name: jaeger
    image: jaegertracing/all-in-one:latest
    environment:
      COLLECTOR_ZIPKIN_HOST_PORT: :9411
    ports:
      - 16686:16686 
      - 4317:4317 
      - 4318:4318 
      - 9411:9411

Pada service.jaeger.ports, port yang diekspose merupakan port untuk:

16686: Jaeger Dashboard
4317: Jaeger OTLP Protobuf dengan protokol gRPC
4318: Jaeger OTLP Protobuf/JSON dengan protokol HTTP
9411: Zipkin Collector

Menjalankan aplikasi yang telah didefinisikan pada docker-compose.yaml, dapat digunakan perintah:

docker compose up --build

Setelah aplikasi berjalan, dapat dicoba hit aplikasi pada endpoint http://127.0.0.1:8080/api/user, jika Webservice dan aplikasi telah terkoneksi, maka akan tampil nama service seperti pada gambar.

span akan muncul untuk mendefinisikan berapa lama durasi yang dibutuhkan untuk menjalankan sebuah proses.

Load Test

Sekarang mari kita coba menggunakan CLI tool hey [https://github.com/rakyll/hey] untuk menjalankan load-test. Perintah berikut dapat digunakan untuk melakukan load-test sederhana:

hey -c 100 -z 10m http://127.0.0.1:8080/api/user

Perintah tersebut akan menjalankan load-test untuk 100 request per second (RPS) selama 10 menit. Hasil yang akan muncul pada halaman Jaeger UI akan terlihat seperti berikut.

Jika loadtest telah selesai dijalankan, maka akan ada report dari hasil loadtest.

Summary:
  Total:    600.9545 secs
  Slowest:  1.2674 secs
  Fastest:  0.1005 secs
  Average:  0.5553 secs
  Requests/sec: 179.9071

  Total data:   7568120 bytes
  Size/request: 70 bytes

Response time histogram:
  0.101 [1] |
  0.217 [21210] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
  0.334 [10993] |■■■■■■■■■■■■■■■■■■■■
  0.451 [10719] |■■■■■■■■■■■■■■■■■■■■
  0.567 [10919] |■■■■■■■■■■■■■■■■■■■■
  0.684 [10830] |■■■■■■■■■■■■■■■■■■■■
  0.801 [10749] |■■■■■■■■■■■■■■■■■■■■
  0.917 [21675] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
  1.034 [10902] |■■■■■■■■■■■■■■■■■■■■
  1.151 [113]   |
  1.267 [5] |


Latency distribution:
  10% in 0.2009 secs
  25% in 0.3027 secs
  50% in 0.6010 secs
  75% in 0.8028 secs
  90% in 0.9604 secs
  95% in 1.0028 secs
  99% in 1.0069 secs

Details (average, fastest, slowest):
  DNS+dialup:   0.0000 secs, 0.1005 secs, 1.2674 secs
  DNS-lookup:   0.0000 secs, 0.0000 secs, 0.0000 secs
  req write:    0.0000 secs, 0.0000 secs, 0.0237 secs
  resp wait:    0.5552 secs, 0.1005 secs, 1.2660 secs
  resp read:    0.0001 secs, 0.0000 secs, 0.0216 secs

Status code distribution:
  [200] 108116 responses

Github Project

Bagi yang ingin mencoba atau melihat kode secara penuh, dapat melakukan klon pada repository berikut: https://github.com/wahyurudiyan/otel-jaeger.

Graph: Simple implementation non-linear data structure with Go

Wahyu Rudiyan Saputra — Thu, 04 Jan 2024 04:44:53 +0000

Brief of Graph

Graph is a non-linear data structure in programming. This data structure commonly implemented for short-path-finding and often use to validate programming skill in a Software Engineer job.

Graph built with connection nodes or commonly called Vertex, each connected Vertex called Edge, and distance of edge usually called Adjacent.

The Algorithm

First of all, you need to define the data storage, let's use Golang struct.

type Graph struct {
    Vertice []*Vertex
}

type Vertex struct {
    Key      int
    Adjacent []*Vertex
}

func isExist(key int, vertices []*Vertex) bool {
    for _, v := range vertices {
        if v.Key == key {
            return true
        }
    }

    return false
}

There are two data types defined that called Graph and Vertex. The Graph is base data type that store all Vertices that inputted in the main code in the future. Then Vertex defined to store the Key and all Adjacent.

In the section below the definition of types, the isExist function written to validate is inputted Key exist in vertices or not. We need to check the key to avoid duplicated inserted key into vertices.

Now, let's write a method of type of Graph to add the Vertices. This method consist of:

Check is the Key exists?
Add Key into graph vertices.

func (g *Graph) AddVertex(vertex int) error {
    // Check is vertex available
    if isExist(vertex, g.Vertice) {
        return fmt.Errorf("vertex is exist")
    }

    // Insert vertex into graph
    g.Vertice = append(g.Vertice, &Vertex{
        Key: vertex,
    })

    return nil
}

At this moment, we can add the vertex into our struct, but we need to get it. Let's write the GetVertex method in our code. We just need to get our vertex by it's key that inserted before. If the key is match, return the vertex from vertices.

func (g *Graph) GetVertex(vertex int) *Vertex {
    for i, v := range g.Vertice {
        if v.Key == vertex {
            return g.Vertice[i]
        }
    }

    return nil
}

Remember, we need to connect the vertex and to set the Edge and append the destination vertex into adjacent of current vertex. So, the logic suppose like this:

Get the current Vertex (from Vertex) and destination vertex. If it's not exist, return error.
Check the destination vertex in current adjacent is exist or not. It should be doesn't exist.
If everything okay, let's insert destination vertex into current adjacent.

func (g *Graph) AddEdge(from int, dest int) error {
    // Check is vertext exists
    fromVertex := g.GetVertex(from)
    destVertex := g.GetVertex(dest)
    if fromVertex == nil || destVertex == nil {
        return fmt.Errorf("vertex from (%v) --> (%v) is not valid", from, dest)
    }

    // Check is adjacent vertex exists or not
    if isExist(destVertex.Key, fromVertex.Adjacent) {
        return fmt.Errorf("edge from vertex (%v) --> (%v) already exists", fromVertex.Key, destVertex.Key)
    }

    // insert new adjacent for from and dest vertex
    fromVertex.Adjacent = append(fromVertex.Adjacent, destVertex)
    return nil
}

Finally, everything is set, and we need to print all vertex and its adjacent, let's write the code.

func (g *Graph) Print() {
    for _, val := range g.Vertice {
        fmt.Printf("(%v): ", val.Key)
        for i, adj := range val.Adjacent {
            if i > 0 {
                fmt.Printf(" -> ")
            }
            fmt.Printf("(%v)", adj.Key)
        }
        fmt.Println()
    }
}

Let's run the code

To run these code, we need to write the main function.

func main() {
    graph := &Graph{}
    graph.AddVertex(0)
    graph.AddVertex(1)
    graph.AddVertex(2)
    graph.AddVertex(3)
    graph.AddVertex(4)
    graph.AddVertex(5)
    graph.AddVertex(6)

    // Set the edges
    graph.AddEdge(0, 1)
    graph.AddEdge(0, 2)
    graph.AddEdge(0, 5)

    graph.AddEdge(1, 0)
    graph.AddEdge(2, 0)
    graph.AddEdge(5, 0)

    graph.AddEdge(2, 1)
    graph.AddEdge(2, 3)
    graph.AddEdge(2, 6)

    graph.AddEdge(1, 2)
    graph.AddEdge(3, 2)
    graph.AddEdge(6, 2)

    graph.AddEdge(6, 5)
    graph.AddEdge(5, 6)

    graph.Print()
}

Output:

(0): (1) -> (2) -> (5)
(1): (0) -> (2)
(2): (0) -> (1) -> (3) -> (6)
(3): (2)
(4): 
(5): (0) -> (6)
(6): (2) -> (5)

For the full code, please look at my gists here: Graph Gists