DEV Community: fajar sp

Tinkering App

fajar sp — Thu, 13 Feb 2025 13:21:53 +0000

The Original Post is here

Tinkering App is a rapid prototyping tool for Laravel developers. It is also a PHP code runner.

This tools allows you to immediately run PHP code. You can use it as a scratchpad to quickly run PHP functions also you can quickly run a Laravel Eloquent query on your database.

Open a project and Tinker Laravel will bootstraps your laravel framework and runs your PHP code in your application.

Installation

Download the binary file

Setting up PHP

Tinker Laravel needs PHP locally on your machine to run execute the code or run artisan commands

Set PHP path and laravel directory apps accordingly

Run Artisan Command

Run PHP Code

Built with:

tauri v2
rust v1.77.2
nodejs v18
vue v3
vite v6
tailwindcss v3

Support:

buy me a coffe ☕️, thanks 😄.

Setting Up Neovim

fajar sp — Wed, 01 Jan 2025 16:19:33 +0000

This Original Post is here

Install NeoVim

wget https://github.com/neovim/neovim/releases/latest/download/nvim-linux64.tar.gz
mkdir nvim
mv nvim-linux64.tar.gz nvim
cd nvim
tar -xvf nvim-linux64.tar.gz
sudo ln -s ~/nvim/nvim-linux64/bin/nvim /usr/local/bin/nvim

Make a backup of your current Neovim configuration files:

# Linux / MacOS (Unix)
mv ~/.config/nvim{,.bak}
mv ~/.local/share/nvim{,.bak}
mv ~/.local/state/nvim{,.bak}
mv ~/.cache/nvim{,.bak}

Using LazyVim

Clone the LazyVim starter repository and open Neovim:

git clone https://github.com/LazyVim/starter ~/.config/nvim && nvim

Remove the .git folder so you can add it to your own repository later:

rm -rf ~/.config/nvim/.git

Full documentation is available here.

Using NvChad

Clone the NvChad starter repository and open Neovim:

git clone https://github.com/NvChad/starter ~/.config/nvim && nvim

The default mappings are defined
here.

Check
configs.md
to ensure your language's LSP server is present there and edit the
configs/lspconfig.lua file to add your language's LSP.

Full documentation is available
here.

Canonical URL
For more detailed information, visit the original post on my blog.

Self-Hosted Media Server with Jellyfin

fajar sp — Tue, 31 Dec 2024 15:43:29 +0000

This Original Post is here

This guide will walk you through setting up a self-hosted media server using
Jellyfin and Docker. We will use Docker Compose to simplify the setup process.

Prerequisites

Docker installed on your system
Docker Compose installed on your system

Step 1: Create Docker Compose Configuration

Create a file named docker-compose.yml with the following content:

volumes:
    config:
    cache:

services:
    jellyfin:
        image: jellyfin/jellyfin
        container_name: jellyfin
        user: 1000:1000
        volumes:
            - config:/config
            - cache:/cache
            - /path/to/your/media:/media
        restart: "unless-stopped"
        environment:
            - JELLYFIN_PublishedServerUrl=http://yourdomain.com
        ports:
            - 8096:8096
            - 8920:8920 # optional
            - 7359:7359/udp # optional
            - 1900:1900/udp # optional
        labels:
            - "traefik.enable=true"
            - "traefik.http.routers.jellyfin.entrypoints=web"
            - "traefik.http.routers.jellyfin.rule=Host(`media.yourdomain.com`)"
            - "traefik.http.services.jellyfin.loadbalancer.server.port=8096"
        networks:
            - traefik

networks:
  traefik:
    external: true

You can remove labels and networks if not using traefik

Replace /path/to/your/media with the actual path to your media files and
yourdomain.com with your actual domain.

Step 2: Start Jellyfin

Navigate to the directory containing your docker-compose.yml file and run the
following command to start Jellyfin:

docker-compose up -d

This command will download the Jellyfin image and start the container in
detached mode.

Step 3: Access Jellyfin

Open your web browser and navigate to http://yourdomain.com:8096 (replace
yourdomain.com with your actual domain). You should see the Jellyfin setup
screen.

Step 4: Setup Jellyfin

Follow the on-screen instructions to complete the Jellyfin setup. You will need
to create an admin account and configure basic settings.

Step 5: Add Media to Jellyfin

Once you have completed the setup, you can add media to your Jellyfin library:

Log in to your Jellyfin server using the admin account you created.
Go to the "Dashboard" from the menu.
Navigate to "Libraries" and click "Add Media Library".
Choose the type of media (e.g., Movies, TV Shows, Music).
Enter a display name for the library.
Click "Folders" and browse to the /media directory (or the path you specified in the Docker Compose file).
Click "OK" and then "Save".

Jellyfin will now scan the specified directory and add your media files to the
library.

Conclusion

You have successfully set up a self-hosted media server using Jellyfin and
Docker. You can now enjoy your media collection from any device with a web
browser.

Notes

You can force the setupwizard to show up by going to the following link:
http://localhost:8096/web/index.html#!/wizardstart.html

Canonical URL
For more detailed information, visit my blog.

Traefik using owned SSL certificate

fajar sp — Tue, 31 Dec 2024 02:51:11 +0000

This Original Post is here

Example docker-compose.yml Configuration for Traefik with SSL Certificate
Below is an example of a docker-compose.yml configuration for Traefik that uses your existing SSL certificate. In this example, we will utilize pre-existing certificate and private key files.

Create the docker-compose.yml File

version: '3.8'

services:
  traefik:
    image: traefik:v2.9
    container_name: traefik
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./certs:/certs
      - /var/run/docker.sock:/var/run/docker.sock
    command:
      - --entrypoints.web.address=:80
      - --entrypoints.websecure.address=:443
      - --providers.docker=true
      - --providers.docker.network=web
      - --api.dashboard=true
      - --log.level=INFO
      - --certificatesresolvers.myresolver.acme.tlschallenge=true
      - --certificatesresolvers.myresolver.acme.email=your-email@example.com
      - --certificatesresolvers.myresolver.acme.storage=/acme.json
      - --tls.certificates.0.certfile=/certs/your-certificate.crt
      - --tls.certificates.0.keyfile=/certs/your-private-key.key
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.api.rule=Host(`traefik.yourdomain.com`)"
      - "traefik.http.routers.api.service=api@internal"
      - "traefik.http.routers.api.tls=true"
      - "traefik.http.routers.api.tls.certresolver=myresolver"
    networks:
      - web

networks:
  web:
    external: false

Explanation

command:

--entrypoints.web.address=:80: Defines the HTTP entrypoint on port 80.
--entrypoints.websecure.address=:443: Defines the HTTPS entrypoint on port 443.
--providers.docker=true: Enables Docker as the service provider.
--providers.docker.network=web: Uses the web network for Docker services.
--api.dashboard=true: Enables the Traefik dashboard.
--log.level=INFO: Sets the log level to INFO.
--certificatesresolvers.myresolver.acme.tlschallenge=true: Enables ACME with the TLS-ALPN-01 challenge (optional, can be commented out if not used).
--certificatesresolvers.myresolver.acme.email=your-email@example.com: Email for ACME (optional, can be commented out if not used).
--certificatesresolvers.myresolver.acme.storage=/acme.json: Specifies the ACME storage location (optional, can be commented out if not used).
--tls.certificates.0.certfile=/certs/your-certificate.crt: Path to your certificate file.
--tls.certificates.0.keyfile=/certs/your-private-key.key: Path to your private key file.

labels:

traefik.enable=true: Enables Traefik for this service.
traefik.http.routers.api.rule=Host(traefik.yourdomain.com): Defines a rule for the API router.
traefik.http.routers.api.service=api@internal: Directs the API router to Traefik's internal service.
traefik.http.routers.api.tls=true: Enables TLS for the API router.
traefik.http.routers.api.tls.certresolver=myresolver: Uses the defined certificate resolver.

Ensure Your Folder Structure is as Follows:

.
├── docker-compose.yml
└── certs
    ├── your-certificate.crt
    └── your-private-key.key

Start Traefik
Once you have all the required files, start Traefik using the following command:

docker-compose up -d

Traefik will now run and use your SSL certificate with the configuration provided through the command and labels.

Canonical URL
For more detailed information, visit the original post on my blog.

Traefik Cloudflare DNS Challenge

fajar sp — Mon, 30 Dec 2024 04:25:06 +0000

This Original Post is here

Example Docker Compose Configuration

traefik:
  image: "traefik:2.3.7"
  container_name: "traefik"
  restart: unless-stopped
  ports:
    - "80:80"
    - "443:443"
    #- "8080:8080"
  environment:
    - CF_DNS_API_TOKEN=${CF_DNS_API_TOKEN}
  volumes:
    - ./traefik/config:/etc/traefik
    - traefik-ssl-certs:/ssl-certs
    - /etc/localtime:/etc/localtime
    - "/var/run/docker.sock:/var/run/docker.sock:ro"
  depends_on:
    - app
  labels:
    - "traefik.enable=true"
    - "traefik.http.routers.traefik.entrypoints=websecure"
    - "traefik.http.routers.traefik.tls.certresolver=myresolver"
    - "traefik.http.routers.traefik.rule=Host(`traefik.domain.id`)"
    - "traefik.http.routers.traefik.service=api@internal"

Replace traefik.domain.id with your actual domain.

Create a .env file and add the following:

CF_DNS_API_TOKEN=

This token can be obtained from Cloudflare.

Steps to Create an API Token in Cloudflare with the Required Permissions to Manage DNS for Your Domain

Step 1: Log In to Your Cloudflare Account

Visit Cloudflare and log in with your credentials.

Step 2: Access the API Tokens Settings

Once logged in, click on your avatar or account name in the top-right corner.
Select My Profile from the dropdown menu.
On the profile page, navigate to the API Tokens tab.

Step 3: Create a New API Token

Click the Create Token button.
Select the Edit zone DNS template or click Create Custom Token if you want to customize the permissions.

Langkah 4: Mengatur Izin API Token

If choosing Create Custom Token:

Token Configuration Steps

Token Name:\
Give your token a name, such as Traefik DNS Challenge.
Permissions:
- Click Add permissions.
- Choose Zone as the service.
- Select DNS as the resource.
- Choose Edit as the action.
Zone Resources:
- Click Add Zone Resources.
- Select Include.
- Choose All Zones or Specific Zone to restrict access to a particular zone.
  - If choosing Specific Zone, specify the domain, e.g., example.com.
Client IP Address Filtering (optional):\
Add specific IP addresses if you want to restrict token usage to certain IPs.
TTL (optional):\
Set a token expiration period if needed.

Step 5: Create and Save the API Token

Click Continue to summary.
Review the token settings to ensure they are correct.
Click Create Token.

Step 6: Save the API Token

Once the token is created, copy and save it in a secure location. > Note: This is the only time the token will be displayed, so ensure you > record it properly.

Create a traefik/config/traefik.yaml file:

global:
  checkNewVersion: false
  sendAnonymousUsage: false

api:
  dashboard: true
  debug: true

accessLog: {}

entryPoints:
  web:
    address: :80

  websecure:
    address: :443

serversTransport:
  insecureSkipVerify: true

http:
  middlewares:
    redirect-to-https:
      redirectScheme:
        scheme: https
        permanent: true

certificatesResolvers:
  myresolver:
    acme:
      email: xxx@gmail.com
      storage: /ssl-certs/acme.json
      dnsChallenge:
        provider: cloudflare
        resolvers:
          - "1.1.1.1:53"
          - "8.8.8.8:53"
        delayBeforeCheck: 5

providers:
  docker:
    endpoint: "unix:///var/run/docker.sock"
    exposedByDefault: false
  file:
    directory: /etc/traefik
    watch: true

Replace xxx@gmail.com with the email you use for Cloudflare.

Running Traefik

Run the following command to start Traefik:

docker compose up -d

Then, access the dashboard via http://traefik.domain.id or the domain you
configured earlier.

Debugging the DNS Challenge Process

To debug the DNS challenge, inspect the file with the following command:

cat /ssl-certs/acme.json

However, you need to access the Traefik container first:

docker exec -it traefik sh

Canonical URL
For more detailed information, visit the original post on my blog.

SQL index types B TREE, HASH, GIST, GIST, BRIN, and GIN

fajar sp — Fri, 27 Dec 2024 01:42:13 +0000

This Original Post is here

Differences Between Index Types: BTREE, HASH, GIST, SPGIST, BRIN, and GIN

Indexes in databases are used to speed up data search and retrieval. PostgreSQL supports various index types designed for specific query types and data structures. Below are the main differences between these index types:

GIST, SPGIST, BRIN, and GIN index features are exclusive to PostgreSQL.

1. BTREE (Balanced Tree)

Characteristics: Balanced tree structure.
Best suited for:
- Search operations involving comparisons (=, <, <=, >, >=).
- Sortable data (e.g., numbers, text, dates).
Advantages:
- Default index type in PostgreSQL.
- Performs well for most common queries.
Disadvantages:
- Inefficient for very large datasets without proper filtering criteria.
- Suboptimal for proximity searches or multidimensional data.

2. HASH

Characteristics: Uses a hash function to generate the index.
Best suited for:
- Exact match searches (=).
Advantages:
- High performance for exact value searches.
Disadvantages:
- Does not support comparison operations (<, >).
- Limited functionality compared to BTREE.

3. GIST (Generalized Search Tree)

Characteristics: Flexible index type for complex data.
Best suited for:
- Multidimensional data such as geospatial, networking, or full-text search.
- Queries requiring special operators (e.g., geographic distance, overlap).
Advantages:
- Supports various data types and operations.
- Suitable for data requiring non-linear comparison functions.
Disadvantages:
- Slower than BTREE for simple queries.

4. SPGIST (Space-Partitioned GIST)

Characteristics: Specialized version of GIST, designed for hierarchical or spatially partitioned data.
Best suited for:
- Geospatial data or data with hierarchy.
- Searching specific points in large spaces (e.g., nearest-neighbor searches).
Advantages:
- More efficient than GIST for sparse or scattered data.
Disadvantages:
- More complex implementation.

5. BRIN (Block Range Indexes)

Characteristics: Block-based index that stores metadata about data ranges in blocks.
Best suited for:
- Very large datasets with sequential or patterned data.
- Queries filtering data by value ranges.
Advantages:
- Very small index size.
- Extremely fast for large datasets with matching patterns.
Disadvantages:
- Inefficient for random or patternless datasets.
- Not ideal for precise searches.

6. GIN (Generalized Inverted Index)

Characteristics: Inverted index storing lists of elements present in a column (similar to a book index).
Best suited for:
- Full-text search or array operations.
- Queries on JSON data or columns with array types.
Advantages:
- Extremely fast for operations involving multiple elements (e.g., word search in text).
- Optimized for complex data structures like JSON or arrays.
Disadvantages:
- Slower index creation compared to BTREE.
- Higher memory consumption.

Comparison Table Summary

Index Type	Best Suited For	Key Operators	Index Size	Speed
BTREE	General searches	`=`, `<`, `>`	Medium	Fast
HASH	Exact value searches	`=`	Small	Very fast
GIST	Multidimensional, geospatial data	Custom	Large	Flexible
SPGIST	Hierarchical, sparse geospatial	Custom	Medium	Efficient
BRIN	Large sequential datasets	Range	Very small	Fast (with pattern)
GIN	Full-text, JSON, array search	`@>`, `<@`, `&&`	Large	Very fast

Conclusion

BTREE: Default, suitable for most use cases.
HASH: For fast single-value searches.
GIST/SPGIST: For complex data like geospatial or hierarchical structures.
BRIN: For large datasets with sequential patterns.
GIN: For full-text, JSON, or array searches.

The choice of index depends on the type of data and the queries frequently executed in your application.

Canonical URL
For more detailed information, visit the original post on my blog.

Sublime Text Config for Laravel

fajar sp — Fri, 27 Dec 2024 01:26:26 +0000

The Original Post is here

Below is the configuration I use when developing Laravel applications with Sublime Text editor.

PLUGINS

git
git blame
git gutter
sidebar menu advanced
syncedsidebar
lsp
lsp intelephense
lsp bash
lsp dockerfile
lsp eslint
lsp volar
vue syntax highlight
lsp svelte
lsp tailwindcss
terminus
fileicons
a file icon
codeium
shell exec

To install plugins, open the Command Palette with cmd + shift + p / alt + shift + p and select "Install Plugin."

LSP

The LSP plugins require Node.js, so the first step is to install Node.js.

Installation guide: https://github.com/nvm-sh/nvm#installing-and-updating

Usage guide: https://github.com/nvm-sh/nvm#usage

Intelephense

After installation, run the following command:

npm -g i intelephense

Open the menu LSP > Servers > LSP-intelephense under "Package Settings" and configure as follows:

{
    "enabled": true,
    "command": [
        "intelephense",
        "--stdio",
    ],
    "scopes": ["source.php", "embedding.php"],
    "syntaxes": ["Packages/PHP/PHP.sublime-syntax"],
    "languageId": "php",
    "initializationOptions": {
        "clearCache": false,
        "licenceKey": "",
    },
}

Open the Command Palette and select Enable LSP: Enable Language Server.

Preferences Settings

Open with cmd + , / alt + ,:

{
    "ignored_packages":
    [
        "Git",
        "Git blame",
        "GitGutter",
        "Vintage",
    ],
    "save_on_focus_lost": true,
    "shell_exec_executable": "/bin/zsh",
    "shell_exec_output": "panel",
    "shell_exec_output_word_wrap": false
}

Key Bindings

[
    {
        "command": "lsp_symbol_definition",
        "args": {
            "side_by_side": false
        },
        "keys": [
            "super+enter"
        ],
        "context": [
            {
                "key": "lsp.session_with_capability",
                "operator": "equal",
                "operand": "definitionProvider"
            },
            {
                "key": "auto_complete_visible",
                "operator": "equal",
                "operand": false
            }
        ]
    },

    {
        "command": "lsp_format_document",
        "keys": [
            "super+shift+'"
        ],
        "context": [
            {
                "key": "lsp.session_with_capability",
                "operator": "equal",
                "operand": "documentFormattingProvider | documentRangeFormattingProvider"
            }
        ]
    },
    { "keys": ["super+b"], "command": "toggle_side_bar" },
    { "keys": ["super+t"], "command": "toggle_terminus_panel" },
    { "keys": ["super+shift+o"], "command": "close_all" },
    {
        "keys": ["super+shift+t"],
        "caption": "Terminus: Open Default Shell in Split Tab",
        "command": "terminus_open",
        "args": {
            "post_window_hooks": [
                ["carry_file_to_pane", {"direction": "down"}]
            ]
        }
    },
    {
      "keys": ["super+shift+;"],
      "command": "shell_exec_run",
      "args": {
        "format": "./vendor/bin/pint"
      }
    }
]

Mouse Bindings

[
    {
        "button": "button1", 
        "count": 1, 
        "modifiers": ["super"],
        "press_command": "drag_select",
        "command": "lsp_symbol_definition"
    },
    {
        "button": "button1", "count": 1, "modifiers": ["ctrl"],
        "press_command": "drag_select",
        "press_args": {"additive": true}
    }
]

Canonical URL
For more detailed information, visit the original post on my blog.

Using Frankenphp with Laravel Octane

fajar sp — Fri, 27 Dec 2024 01:10:36 +0000

The Original Post is here

in your existing laravel app, install laravel octane using this command

composer require laravel/octane
php artisan octane:install --server=frankenphp

adjust env variable OCTANE_SERVER=frankenphp

run frankenphp with this command:

php artisan octane:frankenphp

The octane:frankenphp command can take the following options:

--host: The IP address the server should bind to (default: 127.0.0.1)
--port: The port the server should be available on (default: 8000)
--admin-port: The port the admin server should be available on (default: 2019)
--workers: The number of workers that should be available to handle requests (default: auto)
--max-requests: The number of requests to process before reloading the server (default: 500)
--caddyfile: The path to the FrankenPHP Caddyfile file (default: stubbed Caddyfile in Laravel Octane)
--https: Enable HTTPS, HTTP/2, and HTTP/3, and automatically generate and renew certificates
--http-redirect: Enable HTTP to HTTPS redirection (only enabled if –https is passed)
--watch: Automatically reload the server when the application is modified
--poll: Use file system polling while watching in order to watch files over a network
--log-level: Log messages at or above the specified log level, using the native Caddy logger

for deployment let's create aDockerfile

i use php 8.2 and postgres database so i need to install pgsql php
extension

FROM dunglas/frankenphp:latest-php8.2

# Install dependencies untuk Composer dan ekstensi PHP
RUN apt-get update && apt-get install -y \
    curl \
    unzip \
    libpq-dev \
    libexif-dev \
    libsodium-dev

# Install Composer
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer

RUN install-php-extensions \
    pgsql \
    pdo_pgsql \
    gd \
    intl \
    zip \
    exif \
    sodium \
    pcntl

WORKDIR /app

COPY . ./

# Install dependencies using Composer
RUN composer install --no-dev --optimize-autoloader

RUN rm -rf ./git

# Run FrankenPHP
CMD ["php", "artisan", "octane:frankenphp", "--host=0.0.0.0", "--port=80", "--admin-port=2019"]

lets build this image using

docker build -t app:latest .

lets create a docker-compose.yml file

services:
    app:
        image: "app:latest"
        restart: unless-stopped
        volumes:
          - ./.env:/app/.env

run it using

docker compose up -d

my use case

i use frankenphp in my personal site using laravel and filamentphp for frontend and
admin panel at https://fajar.labkita.my.id, the
speed is amazing :)

Reference

Canonical URL
For more detailed information, visit the original post on my blog.

Deploy Laravel to Vercel

fajar sp — Thu, 26 Dec 2024 02:43:46 +0000

The Original Post is here

Easy, Free, Serverless Laravel With Vercel

First in your existing project create this file api/index.php

<?php

// Forward Vercel requests to normal index.php
require __DIR__ . '/../public/index.php';

Vercel only allows an app’s entry-point to live inside the api directory, then
we have to set up a simple script to forward to Laravel’s normal
public/index.php entry-point

Create file .vercelignore to ignore vendor dir when deployed

/vendor

Create file vercel.json, the explanation is
here

{
    "version": 2,
    "framework": null,
    "builds": [
        {
            "src": "/api/index.php",
            "use": "vercel-php@0.6.2"
        },
        {
            "src": "/public/build/assets/**",
            "use": "@vercel/static"
        },
        {
            "src": "/public/**",
            "use": "@vercel/static"
        }
    ],
    "routes": [
        {
            "src": "/build/assets/(.*)",
            "dest": "/public/build/assets/$1"
        },
        {
            "src": "/favicon.ico",
            "headers": {
                "Content-Type": "image/x-icon"
            },
            "dest": "/public/favicon.ico"
        },
        {
            "src": "/(.*)",
            "dest": "/api/index.php"
        }
    ],
    "outputDirectory": "public",
    "env": {
        "APP_NAME": "Your App Name",
        "APP_ENV": "production",
        "APP_DEBUG": "false",
        "APP_URL": "https://laravel-app.vercel.app",

        "LOG_CHANNEL": "stderr",
        "CACHE_DRIVER": "array",
        "SESSION_DRIVER": "array",

        "APP_CONFIG_CACHE": "/tmp/config.php",
        "APP_EVENTS_CACHE": "/tmp/events.php",
        "APP_PACKAGES_CACHE": "/tmp/packages.php",
        "APP_ROUTES_CACHE": "/tmp/routes.php",
        "APP_SERVICES_CACHE": "/tmp/services.php",
        "VIEW_COMPILED_PATH": "/tmp"
    }
}

vercel-php is a community-built PHP runtime for Vercel functions. It does all
the hard work for us like installing the proper dependencies and running
composer install. Please change this vercel-php@0.6.2 version refer to this
link
https://github.com/vercel-community/php
adjust it according with your php version

Change APP_URL with your prefered domain name, this will be setted as your
production domain.

You can change CACHE_DRIVER or SESSION_DRIVER using redis.

For more sensitive environment variables like APP_KEY or anything that you dont
want people to know it, you can visit the vercel Environment Variables tab in
your project’s Settings:

Install Vercel CLI

Install in your local machine, check this link

run vercel login and follow the instruction

to deploy in preview mode, run

vercel deploy

when finished you can click the preview link provided from vercel

to deploy in preview production mode, run

vercel --prod

when finished you can click the production link provided from vercel

Summary

This makes it incredibly easy to deploy apps to vercel even if we use php and
laravel

Because Vercel is serverless, your database has to be hosted on a separate cloud
platform.

To link your database with Vercel is actually easy you just need to update the
Environment Variables in vercel.json or in vercel project’s Settings.

Canonical URL

For more detailed information, visit the original post on my blog.

Redis Queue and Cron in Go

fajar sp — Thu, 26 Dec 2024 02:32:21 +0000

The original post is here

In this tutorial, we will interact with a queue and put it to a Redis server
using the github.com/hibiken/asynq package and create a scheduler for a
scheduled task using the github.com/robfig/cron package. This step-by-step
guide explains how to set up a queue, schedule tasks, and handle graceful
shutdowns.

Initialize the Module

Start by creating a new Go module for the project:

go mod init learn_queue_and_cron

Create `cron.go`

The cron.go file is responsible for scheduling and running tasks at specific
intervals. Below is the implementation:

package main

import (
    "fmt"
    "log"
    "time"

    "github.com/robfig/cron/v3"
)

func runCron(c *cron.Cron) {

    // Schedule a task to run every minute
    _, err := c.AddFunc("@every 1m", func() {
        fmt.Printf("Task executed every minute at: %v \n", time.Now().Local())
    })
    if err != nil {
        log.Fatal(err)
    }

    // Start the cron scheduler
    c.Start()
    log.Println("Cron scheduler started")

    // Keep the main goroutine running
    select {}
}

This code schedules a task to run every minute and keeps the application running
to ensure the scheduler works continuously.

Create `queue.go`

The queue.go file manages task processing using Asynq. Here's the code:

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    "github.com/hibiken/asynq"
)

func runQueue(server *asynq.Server) {
    mux := asynq.NewServeMux()
    mux.HandleFunc("send_email", emailHandler)
    mux.HandleFunc("generate_report", reportHandler)

    if err := server.Run(mux); err != nil {
        log.Fatalf("Failed to run Asynq server: %v", err)
    }
}

func emailHandler(ctx context.Context, task *asynq.Task) error {
    var payload struct {
        To string `json:"to"`
    }
    if err := json.Unmarshal(task.Payload(), &payload); err != nil {
        return fmt.Errorf("failed to unmarshal payload: %w", err)
    }
    fmt.Printf("Sending email to: %s\n", payload.To)
    return nil
}

func reportHandler(ctx context.Context, task *asynq.Task) error {
    var payload struct {
        ReportID int `json:"report_id"`
    }
    if err := json.Unmarshal(task.Payload(), &payload); err != nil {
        return fmt.Errorf("failed to unmarshal payload: %w", err)
    }
    fmt.Printf("Generating report for ID: %d\n", payload.ReportID)
    return nil
}

Explanation

Handlers: emailHandler and reportHandler process tasks by parsing their payloads and executing the respective actions.
Task Queue: Tasks such as "send_email" and "generate_report" are defined and processed via Asynq's task queue.

Create `router.go`

The router.go file sets up HTTP endpoints to enqueue tasks:

package main

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

    "github.com/gin-gonic/gin"
    "github.com/hibiken/asynq"
)

func setupRouter(client *asynq.Client) *gin.Engine {
    r := gin.Default()

    r.POST("/enqueue/email", func(c *gin.Context) {
        var payload struct {
            To string `json:"to"`
        }
        if err := c.ShouldBindJSON(&payload); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request body"})
            return
        }

        jsonPayload, err := json.Marshal(payload)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to marshal payload"})
            return
        }

        task := asynq.NewTask("send_email", jsonPayload)
        _, err = client.Enqueue(task)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to enqueue task"})
            return
        }

        c.JSON(http.StatusOK, gin.H{"message": "Email job enqueued"})
    })

    r.POST("/enqueue/report", func(c *gin.Context) {
        var payload struct {
            ReportID int `json:"report_id"`
        }
        if err := c.ShouldBindJSON(&payload); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request body"})
            return
        }

        jsonPayload, err := json.Marshal(payload)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to marshal payload"})
            return
        }

        task := asynq.NewTask("generate_report", jsonPayload)
        _, err = client.Enqueue(task)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to enqueue task"})
            return
        }

        c.JSON(http.StatusOK, gin.H{"message": "Report job enqueued"})
    })

    return r
}

This code uses the Gin framework to expose two endpoints for enqueuing tasks.

Create `main.go`

The main.go file integrates everything together:

package main

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

    "github.com/hibiken/asynq"
    "github.com/robfig/cron/v3"
)

func main() {
    c := cron.New()

    server := asynq.NewServer(
        asynq.RedisClientOpt{Addr: "localhost:6379"},
        asynq.Config{
            Concurrency: 10,
        },
    )

    client := asynq.NewClient(asynq.RedisClientOpt{Addr: "localhost:6379"})
    defer client.Close()

    router := setupRouter(client)

    httpServer := &http.Server{
        Addr:    ":8080",
        Handler: router,
    }

    // Prepare shutdown context
    ctx, stop := context.WithCancel(context.Background())
    defer stop()
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, os.Interrupt, syscall.SIGTERM)

    go runQueue(server)
    go runCron(c)
    go func() {
        if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("Failed to run HTTP server: %v", err)
        }
    }()

    appShutdown(ctx, httpServer, c, server, quit)
}

func appShutdown(ctx context.Context, httpServer *http.Server, c *cron.Cron, server *asynq.Server, quit chan os.Signal) {
    // Wait for termination signal
    <-quit
    log.Println("Shutting down gracefully...")

    httpCtx, httpCancel := context.WithTimeout(ctx, 5*time.Second)
    defer httpCancel()
    if err := httpServer.Shutdown(httpCtx); err != nil {
        log.Printf("HTTP server shutdown error: %v", err)
    }

    server.Shutdown()
    c.Stop()

    log.Println("Application stopped")
}

This file combines the queue, cron, HTTP server, and shutdown logic.

Install Dependencies

Install all required dependencies:

go mod tidy

Build and Run the Application

Build and run the application using:

go build -o run *.go && ./run

Test the Application

Visit the following endpoints to enqueue tasks:

Watch the terminal for the task execution logs.

Canonical URL

For more detailed information, visit the original post on my blog.

DEV Community: fajar sp

Tinkering App

Installation

Setting up PHP

Run Artisan Command

Run PHP Code

Built with:

Support:

Setting Up Neovim

Install NeoVim

Using LazyVim

Using NvChad

Self-Hosted Media Server with Jellyfin

Prerequisites

Step 1: Create Docker Compose Configuration

Step 2: Start Jellyfin

Step 3: Access Jellyfin

Step 4: Setup Jellyfin

Step 5: Add Media to Jellyfin

Conclusion

Notes

Traefik using owned SSL certificate

Traefik Cloudflare DNS Challenge

Example Docker Compose Configuration

Steps to Create an API Token in Cloudflare with the Required Permissions to Manage DNS for Your Domain

Step 1: Log In to Your Cloudflare Account

Step 2: Access the API Tokens Settings

Step 3: Create a New API Token

Langkah 4: Mengatur Izin API Token

Token Configuration Steps

Step 5: Create and Save the API Token

Step 6: Save the API Token

Running Traefik

Debugging the DNS Challenge Process

SQL index types B TREE, HASH, GIST, GIST, BRIN, and GIN

Differences Between Index Types: BTREE, HASH, GIST, SPGIST, BRIN, and GIN

1. BTREE (Balanced Tree)

2. HASH

3. GIST (Generalized Search Tree)

4. SPGIST (Space-Partitioned GIST)

5. BRIN (Block Range Indexes)

6. GIN (Generalized Inverted Index)

Comparison Table Summary

Conclusion

Sublime Text Config for Laravel

PLUGINS

LSP

Intelephense

Preferences Settings

Key Bindings

Mouse Bindings

Using Frankenphp with Laravel Octane

my use case

Reference

Deploy Laravel to Vercel

Easy, Free, Serverless Laravel With Vercel

Install Vercel CLI

Summary

Canonical URL

Redis Queue and Cron in Go

Initialize the Module

Create cron.go

Create queue.go

Explanation

Create router.go

Create main.go

Install Dependencies

Build and Run the Application

Test the Application

Canonical URL

Create `cron.go`

Create `queue.go`

Create `router.go`

Create `main.go`