Andrei Telteu

Cum să configurezi Headscale și Traefik ca să faci proxy la orice serviciu

Sat, 25 Jan 2025 20:04:00 +0200

Andrei Telteu https://telteu.ro/ro/posts/headscale-cu-traefik/ -

Requirements:

a linux server with a public IPv4 address
docker and docker compose installed
a domain/subdomain with a A DNS record pointing to your IP

I will use example.com as the domain name in this example, please replace it with your domain/subdomain.

Traefik

Ssh to your public server where you want to host your vpn, make a folder called traefik with the following files: mkdir traefik && cd traefik

1. An empty `letsencrypt` folder: `mkdir letsencrypt`

2. An empty file `touch dynamic.yml` (for future expansion)

3. The static config: `nano static.yml`

 1api:
 2 insecure: true
 3 dashboard: true
 4
 5providers:
 6 docker:
 7 exposedByDefault: false
 8
 9entryPoints:
10 web:
11 address: ":80"
12 http2:
13 maxConcurrentStreams: 250 # fix for network error on the proxy to my immich instance
14 http3:
15 advertisedPort: 443
16 # http:
17 # redirections:
18 # entryPoint:
19 # to: websecure
20 # scheme: https
21 forwardedHeaders:
22 trustedIPs:
23 - 10.0.0.0/8
24 - 172.16.0.0/12
25 - 192.168.0.0/16
26 - fc00::/7
27 proxyProtocol:
28 trustedIPs:
29 - 10.0.0.0/8
30 - 172.16.0.0/12
31 - 192.168.0.0/16
32 - fc00::/7
33 websecure:
34 address: ":443"
35 http2:
36 maxConcurrentStreams: 250 # fix for network error on the proxy to my immich instance
37 http3:
38 advertisedPort: 443
39 forwardedHeaders:
40 trustedIPs:
41 - 10.0.0.0/8
42 - 172.16.0.0/12
43 - 192.168.0.0/16
44 - fc00::/7
45 proxyProtocol:
46 trustedIPs:
47 - 10.0.0.0/8
48 - 172.16.0.0/12
49 - 192.168.0.0/16
50 - fc00::/7
51
52certificatesResolvers:
53 myresolver:
54 acme:
55 email: "your-email-goes-here@tutorial.example"
56 storage: "/letsencrypt/acme.json"
57 httpChallenge:
58 entryPoint: web

Replace your-email-goes-here@tutorial.example with your email address. Let’s Encrypt send you notifications when your ssl certificate expires.

4. The docker compose config: `nano compose.yml`

 1services:
 2
 3 traefik:
 4 image: "traefik:v3.2"
 5 container_name: "traefik"
 6 restart: "always"
 7 ports:
 8 - "80:80"
 9 - "443:443"
10 networks:
11 - pub
12 volumes:
13 - "./letsencrypt:/letsencrypt"
14 - "/var/run/docker.sock:/var/run/docker.sock:ro"
15 - "./static.yml:/etc/traefik/traefik.yml:ro"
16 - "./dynamic.yml:/etc/traefik/dynamic.yaml:ro"
17 labels:
18 - "traefik.enable=true"
19 - "traefik.http.routers.dashboard.rule=Host(`example.com`) && (PathPrefix(`/dashboard`) || PathPrefix(`/api/overview`) || PathPrefix(`/api/version`) || PathPrefix(`/api/http`) || PathPrefix(`/api/entrypoints`) || PathPrefix(`/api/tcp`) || PathPrefix(`/api/udp`))"
20 - "traefik.http.routers.dashboard.entrypoints=websecure"
21 - "traefik.http.routers.dashboard.tls.certresolver=myresolver"
22 - "traefik.http.routers.dashboard.service=api@internal"
23 # # if you want to password protect your traefik dashboard uncomment the following and change the user:pass
24 #- "traefik.http.routers.dashboard.middlewares=auth"
25 #- "traefik.http.middlewares.auth.basicauth.users=" # to create user and pass: bash -c 'echo $(htpasswd -nB admin) | sed -e s/\\$/\\$\\$/g'
26
27networks:
28 pub:
29 external: true

Create the pub network first using the command docker network create pub

Now we can start the traefik instance: docker compose up -d

HeadScale

Let’s make a separate folder for headscale: cd .. && mkdir headscale

1. 2 empty folders: `mkdir data && mkdir tailscale-client`

2. The headscale config: `nano config.yml`

 1---
 2# The url clients will connect to.
 3server_url: https://example.com
 4
 5# Address to listen to / bind to on the server
 6listen_addr: 0.0.0.0:8080
 7
 8# Address to listen to /metrics, you may want
 9metrics_listen_addr: 127.0.0.1:9090
 10
 11# Address to listen for gRPC.
 12grpc_listen_addr: 127.0.0.1:50443
 13
 14# Allow the gRPC admin interface to run in INSECURE mode.
 15grpc_allow_insecure: false
 16
 17noise:
 18 # The Noise private key is used to encrypt the traffic
 19 private_key_path: /var/lib/headscale/noise_private.key
 20
 21# List of IP prefixes to allocate tailaddresses from.
 22# Each prefix consists of either an IPv4 or IPv6 address,
 23prefixes:
 24 v6: fd7a:115c:a1e0::/48
 25 v4: 100.64.0.0/10
 26 # Strategy used for allocation of IPs to nodes, available options:
 27 # - sequential (default): assigns the next free IP from the previous given IP.
 28 # - random: assigns the next free IP from a pseudo-random IP generator (crypto/rand).
 29 allocation: sequential
 30
 31# DERP is a relay system that Tailscale uses when a direct connection cannot be established.
 32derp:
 33 server:
 34 enabled: false
 35 # Region ID to use for the embedded DERP server.
 36 region_id: 999
 37 region_code: "headscale"
 38 region_name: "Headscale Embedded DERP"
 39 # Listens over UDP at the configured address for STUN connections - to help with NAT traversal.
 40 stun_listen_addr: "0.0.0.0:3478"
 41 # Private key used to encrypt the traffic between headscale DERP and Tailscale clients.
 42 private_key_path: /var/lib/headscale/derp_server_private.key
 43 # This flag can be used, so the DERP map entry for the embedded DERP server is not written automatically,
 44 automatically_add_embedded_derp_region: true
 45 # For better connection stability (especially when using an Exit-Node and DNS is not working),
 46 ipv4: 1.2.3.4
 47 ipv6: 2001:db8::1
 48 # List of externally available DERP maps encoded in JSON
 49 urls:
 50 - https://controlplane.tailscale.com/derpmap/default
 51 # Locally available DERP map files encoded in YAML
 52 paths: []
 53 # If enabled, a worker will be set up to periodically refresh the given sources and update the derpmap
 54 auto_update_enabled: true
 55 # How often should we check for DERP updates?
 56 update_frequency: 24h
 57# Disables the automatic check for headscale updates on startup
 58disable_check_updates: false
 59# Time before an inactive ephemeral node is deleted?
 60ephemeral_node_inactivity_timeout: 30m
 61database:
 62 type: sqlite
 63 # Enable debug mode. This setting requires the log.level to be set to "debug" or "trace".
 64 debug: false
 65 gorm:
 66 prepare_stmt: true
 67 parameterized_queries: true
 68 skip_err_record_not_found: true
 69 slow_threshold: 1000
 70 sqlite:
 71 path: /var/lib/headscale/db.sqlite
 72 write_ahead_log: true
 73
 74 ### TLS configuration Let's encrypt / ACME
 75acme_url: https://acme-v02.api.letsencrypt.org/directory
 76acme_email: "your-email-goes-here@tutorial.example"
 77tls_letsencrypt_hostname: ""
 78# Path to store certificates and metadata needed by letsencrypt
 79tls_letsencrypt_cache_dir: /var/lib/headscale/cache
 80
 81# Type of ACME challenge to use, currently supported types: HTTP-01 or TLS-ALPN-01
 82tls_letsencrypt_challenge_type: HTTP-01
 83# When HTTP-01 challenge is chosen, letsencrypt must set up a verification endpoint, and it will be listening on:
 84tls_letsencrypt_listen: ":http" # :http = port 80
 85tls_cert_path: ""
 86tls_key_path: ""
 87
 88log:
 89 format: text # text or json
 90 level: info
 91
 92policy:
 93 mode: file
 94 path: ""
 95
 96dns:
 97 magic_dns: true
 98 # Defines the base domain to create the hostnames for MagicDNS.
 99 base_domain: head.local
100 nameservers:
101 global:
102 - 1.1.1.1
103 - 1.0.0.1
104 - 2606:4700:4700::1111
105 - 2606:4700:4700::1001
106 split: {}
107 search_domains: []
108 # Extra DNS records
109 extra_records: []
110
111unix_socket: /var/run/headscale/headscale.sock
112unix_socket_permission: "0770"
113logtail:
114 # Enable logtail for this headscales clients.
115 enabled: false
116# Enabling this option makes devices prefer a random port for WireGuard traffic over the default static port 41641.
117randomize_client_port: false

It’s the default config, I removed some comments and replaced server_url, acme_email and the base_domain from dns section. This last config is the Magic DNS that headscale uses to create a DNS entry for every device you connect to your tailscale vpn.

3. The docker compose config: `nano compose.yml`

 1services:
 2
 3 headscale:
 4 container_name: headscale
 5 image: headscale/headscale
 6 command: serve
 7 restart: always
 8 ports:
 9 - "8080:8080"
10 networks:
11 - pub
12 volumes:
13 - "./data:/var/lib/headscale"
14 - "./config.yml:/etc/headscale/config.yaml"
15 cap_add:
16 - NET_ADMIN
17 - SYS_MODULE
18 sysctls:
19 - net.ipv4.ip_forward=1
20 - net.ipv4.conf.all.src_valid_mark=1
21 labels:
22 - "traefik.enable=true"
23 - "traefik.http.routers.headscale.rule=Host(`example.com`)"
24 - "traefik.http.routers.headscale.entrypoints=websecure"
25 - "traefik.http.routers.headscale.tls.certresolver=myresolver"
26 - "traefik.http.services.headscale.loadbalancer.server.port=8080"
27
28 headplane:
29 container_name: headplane
30 image: ghcr.io/tale/headplane:0.3.2
31 restart: unless-stopped
32 ports:
33 - '3000:3000'
34 networks:
35 - pub
36 depends_on:
37 - headscale
38 volumes:
39 - "./config.yml:/etc/headscale/config.yaml"
40 environment:
41 HEADSCALE_URL: 'http://headscale:8080'
42 API_KEY: ""
43 CONFIG_FILE: "/etc/headscale/config.yaml"
44 COOKIE_SECRET: 'put-some-random-string-here-32j564b64kl6n34lk'
45 DISABLE_API_KEY_LOGIN: 'true'
46 COOKIE_SECURE: 'false'
47 HOST: '0.0.0.0'
48 PORT: '3000'
49 labels:
50 - "traefik.enable=true"
51 - "traefik.http.routers.headplane.rule=Host(`example.com`) && PathPrefix(`/admin`)"
52 - "traefik.http.routers.headplane.entrypoints=websecure"
53 - "traefik.http.routers.headplane.tls.certresolver=myresolver"
54 - "traefik.http.services.headplane.loadbalancer.server.port=3000"
55 #- "traefik.http.routers.headplane.middlewares=auth" # uncomment this only if you generated a password in traefik step 4
56
57 # client:
58 # container_name: tailscale-client
59 # image: tailscale/tailscale
60 # restart: unless-stopped
61 # environment:
62 # - "TS_AUTHKEY="
63 # - "TS_STATE_DIR=/var/lib/tailscale"
64 # - "TS_USERSPACE=false"
65 # - "TS_EXTRA_ARGS=--login-server=https://example.com --advertise-exit-node --hostname=server-client --shields-up=false"
66 # networks:
67 # - pub
68 # volumes:
69 # - "./tailscale-client:/var/lib/tailscale"
70 # - "/dev/net/tun:/dev/net/tun"
71 # cap_add:
72 # - net_admin
73 # - sys_module
74
75networks:
76 pub:
77 external: true

We can start headscale now: docker compose up -d

- https://telteu.ro/ro/posts/headscale-cu-traefik/ - Andrei Telteu 2024

MiniPC rack Partea 1: pc și carcasă

Tue, 19 Nov 2024 00:16:30 +0000

Andrei Telteu https://telteu.ro/ro/posts/minipc-rack-partea-1/ -

Hardware

Căutam să încep un homelab cu un mini pc și în sfârșit am găsit o oferta bună second hand:

HP EliteDesk 705 G4 cu AMD Ryzen 5 2400GE, 16GB RAM DDR4 2666 Mhz (sodimm/laptop), cu sursă de 90W pentru doar 450 lei (~90€ / ~95$).

Oferă un balanț bun între preț și performanță pentru că procesorul are 4 nuclee 8 thread-uri la 3.8 GHz. Performanța procesorului este cel mai important lucru pentru mine.
Am cumpărat unu ca să îl testez, apoi am cumpărat încă 2:

Apoi am găsit altă ofertă pentru SSD TeamGroup 512 GB M.2 NVMe pentru doar 120 lei (~24€ / ~25$) (nou/sigilat).

Perfect !

Software

Am început să caut un hypervisor bun, gratuit și ușor de configurare și de folosit.
Am încercat Proxmox dar apoi am găsit XCP-NG cu XEN Orchestra pe canalul de youtube Lawrence Systems și căutarea s-a încheiat. Are multe funcții care m-au convins că este cea mai bună alegere pentru mine:

Gratis și open source
Interfață ușor de folosit și oarecum similară cu interfața altor provideri de VPS
Funcția de replicare și migrare a unui VM pe alt host
Snapshot-uri

Carcasă printată 3D

După ceva timp am găsit o ofertă bună pentru o imprimantă 3D și am început să învăț cum să printez, optimizez setări, apoi am învățat cum să modelez câteva componente simple.

Am început să caut pe yeggi.com (motor de căutare pentru modele 3D) pentru modele de carcase compatibile cu modelul meu și l-am găsit pe cel mai bun:

“HP Mini Staggered Rack Mount” de @dsluo_362876

Idea e perfectă: încorporează MiniPC-ul și sursa lui în aceeași carcasă compactă. Execuția e perfectă ! Modelul este foarte bine gândit.

O singură problemă: Imprimanta mea BambuLab A1 Mini are o dimensiune mică de printare de 180x180x180 mm și a trebuit să rotesc modelul la 45 de grade și să șterg partea groasă de sus a casei.

Problemă rezolvată ! Încape la milimetru pe imprimantă ! Să dăm drumul la printare !

Am oprit printarea după 2-3 cm ca să verific că se potriveste bine modelul și să nu îl printez degeaba dacă nu se potrivește.
Este o practică foarte bună și îți recomand să faci la fel !
Bine că l-am oprit să verific că mi-am dat seama că sursa mea este mai mare decât cea a autorului în toate dimensiunile. Autorul a scris dimensiunile sursei în descrierea modelului dar nu am citit.

Acum sunt blocat. Trebuie să modific modelul ca să încapă sursa mea de 90W dar nu știu cum să îl modific și nu am fișierele sursă, am doar fișierele STL mesh.

Va urma… citește partea 2

- https://telteu.ro/ro/posts/minipc-rack-partea-1/ - Andrei Telteu 2024

Cum să controlezi ventilatorul Noctua din Raspberry Pi

Mon, 18 Nov 2024 00:14:52 +0200

Andrei Telteu https://telteu.ro/ro/posts/cum-sa-controlezi-ventilator-noctua-din-raspberry-pi/ -

Îmi construiesc un homelab și am nevoie să controlez ventilatorul Noctua NF-A20 PWM chromax.black.swap 200x200mm folosind Raspberry Pi. Așa am reușit să fac asta.

Componente necesare:

Un Raspberry Pi
Ventilatorul Noctua NF-A20 PWM (ar trebui să funcționeze la fel și cu alte ventilatoare de 12V)
Un multimetru
Sursă Ridicătoare LM2577 DC-DC
Transistor NPN
Rezistență de 1K Ohm

Diagramă:

Să începem de la Pi:

1- Conectează un fir de la pin-ul GPIO 16, sau orice pin simplu, la rezistența de 1k, apoi conectează celălalt capăt la tranzistor pe pin-ul din mijloc.

2- Un fir de la pin-ul din dreapta al tranzistorului la orice pin Ground sau minus/negativ al Pi-ului. Fața tranzistorului este cea plată.

3- Un fir de la pin-ul din dreapta al tranzistorului la conectorul negativ/minus de 5V marcat “IN-” al sursei ridicătoare.

4- Un fir de la orice pin de 5V al Pi-ului (le găsești în parea de sus, dreapta) la conectorul pozitiv/plus de 5V marcat “IN+” al sursei ridicătoare.

5- Important: ajustează sursa la 12V sau mai puțin.
NU conecta ventilatorul acum pentru că îl poți arde instant dacă îl conectezi la o tensiune mai mare decat 12V.
    A- Ca să pornești sursa ridicătoare temporar conectează un fir de la un pin ground/minus/negativ al Pi-ului direct la teminalul marcat “IN-” al sursei SAU poți executa codul python din urmatoarea secțiune. Trebuie doar să execuți speed(fan, 100) / time.sleep(180).
    B- Conectează multimetru la conectorii marcați “OUT+” și “OUT-” apoi selectează măsurarea voltajului la multimetru (de obicei marcat cu “2V”).
    C- Pe sursă învârte șurubul mic și galben de pe componenta albastră până când multimetrul arată 12V sau puțin mai mic, ca să fim siguri ca nu se strică. Eu l-am lăsat pe al meu la 11.5V.

D- Când ești gata deconectează multimetrul și firul conectat la ground, sau oprește programul python.

Am găsit schema pin-urilor ventilatorului Noctua aici: https://faqs.noctua.at/en/support/solutions/articles/101000081757-what-pin-configuration-do-noctua-fans-use-

5- Un fir de la conectorul marcat “OUT-” (12V negativ) al sursei la pin-ul 1 al conectorului noctua.

6- Un fir de la conectorul marcat “OUT+” (12V pozitiv) al sursei la pin-ul 2 al conectorului noctua.

5- Un fir de la pin-ul 4 al conectorului noctua la pin-ul GPIO 12 al Pi-ului. Acest pin are capabilitate PWM .

Codul python:

Am folosit următorul cod din acest tutorial publicat pe the-diy-life.com de Michael Klements ( cod sursă ), și l-am modificat ca să folosească tranzistorul ca să oprească ventilatorul pentru că ventilatorul nu poate scădea viteza până la 0 RPM. Viteza minimă de rotație este de 20% (350RPM).

 1#!/usr/bin/env python3
 2import RPi.GPIO as GPIO
 3import time
 4import signal
 5import sys
 6
 7# Ventilatorul Noctua PWM are nevoie de 25 kHz (kilo!), vezi pagina 6 de pe:
 8# https://noctua.at/pub/media/wysiwyg/Noctua_PWM_specifications_white_paper.pdf
 9PWM_FREQ = 25 # [Hz] frecvență PWM
10FAN_PIN = 12 # pin BCM pentru control ventilator PWM
11TRAN_PIN = 16 # NPN Transistor
12
13def speed(fan, percent):
14 print("set fan to", percent)
15 if (percent < 20):
16 GPIO.output(TRAN_PIN, False)
17 fan.ChangeDutyCycle(20)
18 else:
19 GPIO.output(TRAN_PIN, True)
20 fan.ChangeDutyCycle(percent)
21
22try:
23 signal.signal(signal.SIGTERM, lambda *args: sys.exit(0))
24 GPIO.setwarnings(True)
25 GPIO.setmode(GPIO.BCM)
26 GPIO.setup(TRAN_PIN, GPIO.OUT)
27 GPIO.setup(FAN_PIN, GPIO.OUT, initial=GPIO.LOW)
28 fan = GPIO.PWM(FAN_PIN, PWM_FREQ)
29
30 # facem cateva cicluri pentru testare
31 speed(fan, 100)
32 time.sleep(30)
33
34 speed(fan, 50)
35 time.sleep(30)
36
37 speed(fan, 0)
38 time.sleep(30)
39
40 speed(fan, 20)
41 time.sleep(30)
42
43 speed(fan, 70)
44 time.sleep(30)
45
46 speed(fan, 100)
47 time.sleep(30)
48
49except KeyboardInterrupt:
50 pass
51
52finally:
53 GPIO.cleanup()

Finalizat!

- https://telteu.ro/ro/posts/cum-sa-controlezi-ventilator-noctua-din-raspberry-pi/ - Andrei Telteu 2024

Cum să folosești Templ în Goravel

Mon, 18 Nov 2024 00:12:52 +0200

Andrei Telteu https://telteu.ro/ro/posts/cum-sa-folosesti-templ-in-goravel/ -

Instaleaza framework-ul si pluginuri

Primul pas este să instalăm Goravel . Este un framework complet cu foarte multe funcții scris în Go pentru programatorii familiari cu framework-ul Laravel.

Pașii din documentația Getting started :

 1// Descarcă framework-ul
 2git clone https://github.com/goravel/goravel.git
 3rm -rf goravel/.git*
 4
 5// Instalează dependențele
 6cd goravel
 7go mod tidy
 8
 9// Crează fișierul .env
10cp .env.example .env
11
12// Generează cheia aplicației
13go run . artisan key:generate

Acum instalează templ pentru randare html și air pentru hot reloading:

1go install github.com/a-h/templ/cmd/templ@latest
2go install github.com/cosmtrek/air@latest

Configurare structură front-end

(încă în lucru - voi actualiza tutorialul cu variabile globale și script push)

• În fișierul /.gitignore adaugă această linie: *_templ.go

• Șterge fișierul resources/views/welcome.tmpl

• Creează 2 foldere în resources/views/ cu numele home și parts

• În folderul resources/views/parts/ creează 3 fișiere:

1. resources/views/parts/header.templ

1package parts
2
3templ Header() {
4 <h1>Header</h1>
5}

2. resources/views/parts/footer.templ

1package parts
2
3templ Footer() {
4 <footer>
5 <p>&copy; 2024 MyProject</p>
6 </footer>
7}

3. resources/views/parts/template.templ

 1package parts
 2
 3templ Template() {
 4 <!DOCTYPE html>
 5 <html>
 6 <head>
 7 <title>My Page</title>
 8 <meta charset="utf-8"/>
 9 <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
10 <meta name="viewport" content="width=device-width, initial-scale=1"/>
11 <!-- Your styles go here -->
12 </head>
13 <body>
14 @Header()
15 { children... }
16 @Footer()
17 <!-- Your scripts go here -->
18 <script src="//unpkg.com/alpinejs" defer></script>
19 </body>
20 </html>
21}

• Creează componenta de pagină principală: resources/views/home/index.templ

 1package home
 2
 3import "goravel/resources/views/parts"
 4
 5templ Index() {
 6 @parts.Template() {
 7 <h1>Homepage</h1>
 8 <div>Templ is awesome</div>
 9 }
10}

Documentația templ pentru componente copii este aici . Există un exemplu pentru o structură layout dar mie îmi place mai mult metoda cu componentă copil.

Folosește componenta pagina principală în controller

Am facut un fișier app/http/controllers/controller.go unde pot salva cateva funcții ajutătoare care vor fii accesibile din orice controller.

 1package controllers
 2
 3import (
 4 "github.com/a-h/templ"
 5 "github.com/goravel/framework/contracts/http"
 6)
 7
 8func RenderTempl(c http.Context, comp templ.Component) http.Response {
 9 c.Response().Status(200)
10 c.Response().Header("Content-Type", "text/html")
11 comp.Render(c, c.Response().Writer())
12 return nil
13}

Funcția asta randează componenta templ în response buffer cu status http 200 Ok. Acum putem folosii funcția în app/http/controllers/home_controller.go

 1package controllers
 2
 3import (
 4 "goravel/resources/views/home"
 5 "github.com/goravel/framework/contracts/http"
 6)
 7
 8type HomeController struct {
 9 //Dependent services
10}
11
12func NewHomeController() *HomeController {
13 return &HomeController{
14 //Inject services
15 }
16}
17
18func (r *HomeController) Index(ctx http.Context) http.Response {
19 // doing awesome stuff here
20 return RenderTempl(ctx, home.Index())
21}

Acum adaugăm o nouă rută:

 1package routes
 2
 3import (
 4 "goravel/app/http/controllers"
 5 "github.com/goravel/framework/facades"
 6)
 7
 8func Web() {
 9 homeController := controllers.NewHomeController()
10 facades.Route().Get("/", homeController.Index)
11}

Configurare hot reloading folosind Air

Goravel are deja configurația pentru Air în fișierul .air.toml, trebuie doar să adăugăm comanda templ generate în parametrul cmd, ca în exemplu:

1[build]
2 bin = "./storage/temp/main"
3- cmd = "go build -o ./storage/temp/main ."
4+ cmd = "templ generate && go build -o ./storage/temp/main ."

Dacă lucrezi pe Windows adaugă .exe dupa cuvantul main și pentru parametrul bin și cmd:

1[build]
2 bin = "./storage/temp/main.exe"
3 cmd = "templ generate && go build -o ./storage/temp/main.exe ."

Gata ! Happy coding !

- https://telteu.ro/ro/posts/cum-sa-folosesti-templ-in-goravel/ - Andrei Telteu 2024

Docker Compose script scurtaturi

Mon, 18 Nov 2024 00:10:52 +0200

Andrei Telteu https://telteu.ro/ro/posts/docker-compose-script-scurtaturi/ -

Make a new file at the root folder called dc without extension.

Content example. Modify for your needs.

 1#!/bin/bash
 2trap "exit" 0
 3DC="docker compose" # add `-f docker/compose.yml` if it's in another folder
 4
 5if [ $# -eq 0 ]; then
 6 $DC ps -a
 7
 8elif [ $1 == "up" ]; then
 9 $DC up -d
10
11elif [ $1 == "php" ]; then
12 if [ $# -gt 1 ]; then
13 $DC exec php su app -c "${*:2}"
14 else
15 $DC exec php su app
16 fi
17
18elif [ $1 == "c" ]; then
19 $DC exec php su app -c "composer ${*:2}"
20
21elif [ $1 == "ci" ]; then
22 $DC exec php su app -c 'composer install'
23
24elif [ $1 == "recreate" ]; then
25 $DC up -d --force-recreate ${*:2}
26
27elif [ $1 == "build" ]; then
28 $DC up -d --force-recreate --build ${*:2}
29
30else
31 $DC $*
32fi

Give execute permission with chmod +x ./dc

And now you can run:

./dc - to show all containers with status
./dc up - to start in detached mode
./dc ci - to run composer install in the php container as user app
./dc c require spatie/image - to run any composer command inside php container
./dc php - interactive exec inside php container
./dc php ls -alh - run any command inside php container
./dc recreate - applies any modifications to docker-compose.yml
./dc recreate php - applies modifications to compose, only for php container
./dc build - if you have a custom dockerfile, does run dc up with a fresh build.
./dc logs -n 10 -f php - any other docker-compose command works as expected.

- https://telteu.ro/ro/posts/docker-compose-script-scurtaturi/ - Andrei Telteu 2024

Backup incremental pentru fișiere și MySQL

Mon, 18 Nov 2024 00:09:52 +0200

Andrei Telteu https://telteu.ro/ro/posts/backup-incremental-pentru-fisiere-si-mysql/ -

1. Instalează

Instalează autorestic de aici: https://autorestic.vercel.app/installation

În tutorialul ăsta folosim următoarea structură de fișiere: /root/backup pentru parole și configurația autorestic, un folder data înauntru unde se salvează backup-urile efective (restic repository), și folderul database unde se salvează temporar exportul din baza de date.

1mkdir /root/backup
2mkdir /root/backup/data
3mkdir /root/backup/database
4cd /root/backup

2. Fisier env pentru parole

Creează fisierul environment nano .autorestic.env și completează datele de access la baza de date:

1AUTORESTIC_LOCAL_RESTIC_PASSWORD=
2
3AUTORESTIC_PROD_DB_MYSQL_HOST=localhost
4AUTORESTIC_PROD_DB_MYSQL_PORT=3306
5AUTORESTIC_PROD_DB_MYSQL_DATABASE=
6AUTORESTIC_PROD_DB_MYSQL_USER=
7AUTORESTIC_PROD_DB_MYSQL_PASS=

Completează la AUTORESTIC_LOCAL_RESTIC_PASSWORD o cheie/parolă random generată. Cu parola asta o să fie encriptate toate backup-urile. Salvează această cheie în alt loc (password manager sau în alt fișier undeva sigur).

3. Script pentru MySQL backup

Creeaza scriptul bash pentru backup MySQL: nano backup-db-hook.sh

 1#!/usr/bin/bash
 2BACKUP_PATH=./database
 3mkdir $BACKUP_PATH
 4
 5export $(cat .autorestic.env | xargs)
 6MYSQL="$(which mysql)"
 7MYSQLDUMP="$(which mysqldump)"
 8GZIP="$(which gzip)"
 9MYSQL_PERMS=" --protocol tcp "
10MYSQL_PERMS+=" -h $(echo $AUTORESTIC_PROD_DB_MYSQL_HOST) "
11MYSQL_PERMS+=" -P $(echo $AUTORESTIC_PROD_DB_MYSQL_PORT) "
12MYSQL_PERMS+=" -u $(echo $AUTORESTIC_PROD_DB_MYSQL_USER) "
13DB="$AUTORESTIC_PROD_DB_MYSQL_DATABASE"
14export MYSQL_PWD="$AUTORESTIC_PROD_DB_MYSQL_PASS"
15DUMP_OPTIONS="--single-transaction --no-tablespaces"
16
17echo "$(date +"%d-%m-%Y %H:%M:%S") Backing up $DB to $BACKUP_PATH"
18TABLES="$($MYSQL $MYSQL_PERMS $DB -Bse 'SHOW TABLES FROM '$DB)"
19for TABLE in $TABLES ; do
20 echo "$(date +"%d-%m-%Y %H:%M:%S") Backing up $TABLE"
21 FILE="$BACKUP_PATH/${TABLE}.sql.gz"
22 $MYSQLDUMP $MYSQL_PERMS $DUMP_OPTIONS $DB $TABLE | $GZIP -9 > $FILE
23done
24echo "$(date +"%d-%m-%Y %H:%M:%S") ...done!"

(script de backup în fișiere separate pentru tabele copiat de la jeremyharris/backup.sh )

4. Configurație Autorestic

Creează fișierul config pentru autorestic: nano auto.yml

 1version: 2
 2
 3backends:
 4 local:
 5 type: local
 6 path: /root/backup/data # aici se salveaza backup-urile in sine
 7
 8global:
 9 forget:
10 keep-daily: 7
11 keep-weekly: 4
12
13locations:
14 prod:
15 from: /var/www/html # calea catre fisierele site
16 to: local
17 cron: '0 1 * * *' # backup fisiere la ora 01:00
18 forget: "yes" # sau "prune". Optiunea "Yes" trebuie să fie în ghilimele, altfel este boolean
19 options:
20 backup:
21 exclude:
22 - 'vendor'
23
24 prod-db:
25 from: /root/backup/database/
26 to: local
27 cron: '0 0 * * *' # backup baza de date la ora 00:00
28 forget: "yes"
29 hooks:
30 before:
31 - bash backup-db-hook.sh

Notă: Numele backend-ului trebuie să fie la fel ca în numele cheii din env: (cum e EXAMPLE)
AUTORESTIC_EXAMPLE_RESTIC_PASSWORD=
backends:
example:
type: local

5. Inițializează folderul cu comanda

1autorestic -c auto.yml -v check

Comanda asta validează configurația și inițiază un nou repository in folderul destinație.

6. Cron Job

Adaugă cron job ca să facă automat backup și purge. Autorestic recomandă cron jobul să fie setat la 5 minute.

crontab -e

1*/5 * * * * cd /root/backup; /usr/local/bin/autorestic -c /root/backup/auto.yml --ci cron --lean

Note:

Salvează cheia (RESTIC_PASSWORD din env) undeva extern, în afara serverului, într-un password manager sau ceva similar. Dacă pierzi cheia backup-urile sunt inutile, nu le poți decripta.
Ca să vezi lista de backup-uri intră în folderul /root/backup și scrie comanda autorestic exec -av snapshots

1## lista backup-urilor
2autorestic -c auto.yml exec -av snapshots
3
4## alege un snapshot id, afișează toate fișierele din acesta
5autorestic -c auto.yml exec -av -- ls --long 041c88da
6
7## acum poți alege să restaurezi doar un fișier, de exemplu, in folderul ./restore/
8autorestic -c auto.yml exec -av -- restore --target=./restore/ --include=/root/backup/database/example.sql.gz 041c88da

- https://telteu.ro/ro/posts/backup-incremental-pentru-fisiere-si-mysql/ - Andrei Telteu 2024

Dinamic max_connections pentru MySQL

Mon, 18 Nov 2024 00:08:54 +0200

Andrei Telteu https://telteu.ro/ro/posts/mysql-max-connections-dinamic/ -

Put the following script in a .sh file, for example in /root/watch-mysql.sh

 1#!/usr/bin/bash
 2trap "exit" 0
 3
 4MAXCONN=1000 # set this to whatever base max_connections you have defined in your my.conf setting
 5while true; do
 6 #mysql -e "SHOW VARIABLES LIKE 'max_connections';"
 7 THREADS=`mysqladmin status | awk '{print $4}'`
 8 THREADSINT=`echo "$THREADS" | bc`
 9 #echo "Load is: $THREADS"
10 NEWMAX=$MAXCONN
11 if [[ $THREADSINT -ge 1 ]]; then
12 NEWMAX=1000
13 fi
14 if [[ $THREADSINT -ge 600 ]]; then
15 NEWMAX=2000
16 fi
17 if [[ $THREADSINT -ge 1400 ]]; then
18 NEWMAX=3000
19 fi
20 if [[ $THREADSINT -ge 2400 ]]; then
21 NEWMAX=4000
22 fi
23 if [[ $THREADSINT -ge 3400 ]]; then
24 NEWMAX=5000
25 fi
26 if [[ $NEWMAX -ne $MAXCONN ]]; then
27 mysql -e "set global max_connections = $NEWMAX;"
28 #echo "increased: $NEWMAX"
29 MAXCONN=$NEWMAX
30 fi
31 sleep 3
32done

If mysqladmin status gives error “connect to server at ’localhost’ failed”, make sure you have your credentials stored in ~/.my.cnf

I have a separate mysql server, runing PerconaDB inside docker, so in my case my ~/.my.cnf looks like this:

[client]
protocol=tcp
port=3306
user=root
password="secret"

You can run this script on startup by creating a systemd service or by using supervisor .

An easier setup is by runing a cron job every minute. If you do a while loop in a cron job, you will end up with unlimited proceses spawned and we don’t want that. Instead we will replace while with a for loop:

# replace `while true; do` with
for i in {1..20}; do

For loop for 20 iterations because each loop sleeps for 3 seconds. So 20 * 3 = 60 seconds assuming our code does not take too long to execute.

Now run command crontab -e and add a cron job for this:

* * * * * bash /root/watch-mysql.sh

- https://telteu.ro/ro/posts/mysql-max-connections-dinamic/ - Andrei Telteu 2024

Calendar complet în Solid JS

Mon, 18 Nov 2024 00:07:59 +0200

Andrei Telteu https://telteu.ro/ro/posts/solid-js-calendar-complet/ -

 1import { Component, For } from "solid-js";
 2import moment from "moment";
 3// import "moment/dist/locale/ro"; // if you need to change the locale
 4// moment.locale("ro");
 5
 6const FullCalendar: Component = () => {
 7 const weekdays = moment.weekdaysMin();
 8 const months = moment.months();
 9 const fullYear = Object.fromEntries(
10 months.map((monthName, monthIndex) => {
11 return [
12 monthName,
13 new Array(6).fill(1).map((i, rowIndex) => {
14 return weekdays.map((dayName, colIndex) => {
15 const day = moment()
16 // .year(2024) // if you need to change the year
17 .month(monthIndex)
18 .date(rowIndex * 7)
19 .weekday(colIndex);
20 return day.month() == monthIndex ? day.format("D") : "";
21 });
22 }),
23 ];
24 })
25 );
26
27 return (
28 <div class="solidcalendar-container">
29 <For each={Object.keys(fullYear)}>
30 {(monthName) => (
31 <div class="solidcalendar-month">
32 <div class="solidcalendar-monthname">{monthName}</div>
33 <div class="solidcalendar-weekdays">
34 <For each={weekdays}>
35 {(weekDayName) => (
36 <div class="solidcalendar-weekday solidcalendar-column">
37 {weekDayName}
38 </div>
39 )}
40 </For>
41 </div>
42
43 <For each={fullYear[monthName]}>
44 {(days) => (
45 <div class="solidcalendar-week">
46 <For each={days}>
47 {(day) => (
48 <div class="solidcalendar-weekday solidcalendar-column">
49 {day}
50 </div>
51 )}
52 </For>
53 </div>
54 )}
55 </For>
56 </div>
57 )}
58 </For>
59 </div>
60 );
61};
62
63export default FullCalendar;

- https://telteu.ro/ro/posts/solid-js-calendar-complet/ - Andrei Telteu 2024