DEV Community: 4rkal

Prevent newsletter signup spam

4rkal — Thu, 17 Apr 2025 14:43:47 +0000

Backstory

I woke up to 200 new subscribers on the newsletter of my site videiro.com, had it finally happened? Did my site finally go viral?

Sadly no. After checking the new subscribers I noticed that none had verified their email addresses, not even one, that’s definitely not a confidence.

After some quick research I understood that I had indeed been spammed. But all the emails look legit. Here are some examples:

kathyolynn@yahoo.com
lukeckins@gmail.com
dispatch@gonealinc.com
doug_fern@hotmail.com

After some initial research (entering the emails into haveibeenpwned) it looks like most of these email addresses have been in some kind of hack or breach.

So what was happening? How can I prevent it in the future?

Someone, decided to use compromised email addresses to spam my form. Either to pollute my newsletter, to see how far they could go or just because they can?

What I learned

When making anything publicly available on the internet, there will be spammers, there will be bots and there will be people trying to hack it. That is why you should always be making it as secure as possible.

It turns out that this kind of spam attack is more common that you think (especially since my blog’s newsletter also got spammed a couple weeks later). Bots crawl the web and look for forms, usually newsletter or contact forms and then start submitting “leaked” email addresses.

But why? Here are some reasons I came up with:

To pollute your email list (if this is a personal attack, which I don’t think it is in this case)
To test the validity of the emails??
To annoy the leaked email addresses owners by having them subscribed to thousands of newsletters
To annoy the website owner (me)

How I fixed it

I have a couple solutions to this problem.

Step 1: Enable Double Opt-in

The fist and most important step is to make sure that all your newsletters are ‘double opt-in’ meaning that the user has to confirm their email address before getting subscribed

On listmonk (the newsletter software I am using) make sure that the list that you are subscribing your users to is double opt in

This means that even if your form gets spammed you can just remove all the addresses that haven’t verified their email (after a couple of days/weeks).

Want to learn how to set up your own self-hosted newsletter with Listmonk?

Check out my guide: How to set up a self-hosted newsletter using Listmonk

Step 2: Add Captcha or Cloudflare JS challenge

The second step I took was to enable some sort of catcha. Initially I setup an hcaptcha via listmonk. But I don’t think that is the best solution as it’s kind of annoying. I am however using it for the videiro.com newsletter. If your interested in how to do it here’s how:

Open the listmonk web-ui
Go to settings
Under Security, enable captcha and enter an hCaptcha.com API key (you will first have to signup at hcaptcha.com)

However with this setup if you are using custom forms (like the email subscription form bellow) the submission process will be kind of broken.

So instead what I came up with and I am currently using on 4rkal.com newsletter is to use cloudflare JS Challenge on a specific subdomain.

The way that I have setup my email newsletter is that I have listmonk running on newsletter.4rkal.com, a seperate subdomain.

This means that I can set that specific subdomain as “under attack” on cloudflare and prompt users to sometimes complete a catcha.

To do this:

Head to cloudflare.com
Login and head to the dashboard of your specific domain
Under Security select WAF
Then click on Create rule
Give it any name
Under Field select hostname and under Operator select wildcard, in Value enter the subdomain, in my case that’s newsletter.4rkal.com. The expression should look like this (http.host wildcard "newsletter.4rkal.com")
Under Choose action select JS Challenge
Click on Save

And that’s about it

Summary

Getting your website spammed is never fun, but I hope this article might have given clarity to people going through the same problem as me.

Deploying Go + Templ + HTMX + TailwindCSS to production

4rkal — Thu, 06 Mar 2025 11:16:29 +0000

I recently created my very own cryptocurrency exchange aggregator called cyphergoat it finds you the best rate to swap your crypto from different partnered exchanges.

It has two parts:

An API that interacts with exchanges. Written in go and uses gin
The Web UI that is written in go and uses a combination of HTML, HTMX, tailwindcss, CSS and Javascript in templ templates. Aka the GoTTH stack. It interacts with the api in order to find rates etc.

What is extremely cool with this stack and setup is that we are able to produce a single binary with everything included for each part and ship it to the server. On the webui side this is possible since the html is compiled into go code using templ and then shipped with the binary.

In this article I will be going through my setup to make it easier for you to make something like this.

Setup

I am using a debian 12 server which will expose my application via cloudflare tunnels. All of the static files are being served via nginx and the api and website binaries are ran as systemd services.

In this guide I will show you how I set this up.

The setup

I have a single folder on my dev machine called cyphergoat: It contains

api/
web/
builds/

The api folder houses the api source code. The web the website source code.

And the builds houses all of the builds that are deployed to the server.

Tailwind

The first real challenge comes with setting up tailwindcss correctly.

In my web project I have a static folder specifically for static files. Inside of it I have two files

/web
    styles.css
    tailwind.css

The styles.css simply contains:

@import "tailwindcss";

The tailwind.css file is where tailwind-cli will save it’s stuff.

To build the tailwind stuff I simply run

npx @tailwindcss/cli -i ./static/styles.css -o ./static/tailwind.css --watch

(assuming you have tailwind-cli installed)

In my header.templ file (the header of all the pages) at the top I have

<link href="https://4rkal.com/static/tailwind.css" rel="stylesheet">

<link href="https://4rkal.com/static/styles.css" rel="stylesheet">

And the files are being served using echo’s e.Static (in my main.go file )

func main(){
e := echo.New()

e.Use(middleware.Logger())
e.Use(middleware.Recover())
e.Use(middleware.Secure())

e.Static("/static", "static") // Serves content from static folder.

// Rest of the handlers
}

Server

On my server side I have a debian 12 vm running on proxmox.

In my users home directory I have a folder with the following contents:

cyphergoat/
├── api
├── static/
└── web

The static folder contains all of the static files (including tailwind.css and styles.css) and the web and api are the binaries.

I then have two systemd services for these exectuables:

Thecg-api.service/etc/systemd/system/cg-api.service

[Unit]
Description=CypherGoat API
After=network.target

[Service]
User=arkal
Group=www-data
WorkingDirectory=/home/arkal/cyphergoat
ExecStart=/home/arkal/cyphergoat/api
Restart=always
RestartSec=1

[Install]
WantedBy=multi-user.target

And cg-web.service/etc/systemd/system/cg-web.service

[Unit]
Description=CypherGoat Web
After=network.target

[Service]
User=arkal
Group=www-data
WorkingDirectory=/home/arkal/cyphergoat
ExecStart=/home/arkal/cyphergoat/web

[Install]
WantedBy=multi-user.target

Both are owned by the group www-data (this is probably not necessary for the api), in order to make it easier to serve them via nginx.

Nginx

The website is communicating with the api but I still need to make the web-ui accessible.

I have setup an nginx site with the following configuration:/etc/nginx/sites-available/cg

server {
    server_name cyphergoat.com;

    location / {
        proxy_pass http://127.0.0.1:4200;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    location /static/ {
        alias /var/www/static/;
        expires 30d;
    }

    # Optional robots.txt
    location = /robots.txt {
        root /var/www/static;
        access_log off;
        log_not_found off;
    }

    listen 80;
}

I have also setup certbot to have an ssl cert.

You can setup certbot by running:

sudo apt install certbot python3-certbot-nginx -y

Generate the ssl cert:

sudo certbot --nginx -d cyphergoat.com

Read Self host your own website for a more in depth nginx setup.

Cloudflare Tunnels

I am currently making my website accessible using cloudflare pages. It is an extremely easy to use port forwarding solution

To do this you will need a cloudflare account and a domain pointed to cloudflare.

First head to the Zero Trust Dashboard

Under Networks click on Tunnels and then Create a tunnel

Once created you should Install and run a connector, follow the instructions on the page for your specific setup.

After the connector is running you should click on the Public Hostname tab and Add a public hostname.

Now you should see something like this:

Fill in the info as I have. The service type should be HTTP and the url should be 127.0.0.1:80 or localhost:80

Obviously there is no reason to make your api publicly accessible when deploying your website.

Deployment

In order to deploy my binaries I went ahead and created a quick bash script:

cd api
go build -o ../builds/ .

cd ../web

templ generate && go build -o ../builds/web cmd/main.go

cd ..
rsync -urvP ./builds/ user@SERVER:/home/user/cyphergoat
rsync -urvP ./web/static user@SERVER:/home/user/cyphergoat/
rsync -urvP ./api/coins.json user@SERVER:/user/user/cyphergoat/

The script will build the api, generate the templ files and build the webui and then sends everything over to my server (including the static folder)

I then ssh into my server

ssh user@ip

and then restart the services

sudo systemctl restart cg-api cg-web

And that’s it.

Join my free newsletter!

Join here

Simple Rate Limiting in Go (Gin)

How to build a URL shortener in Go

How to deploy django to production

If Linux is so great why isn't everyone using it?

4rkal — Sun, 13 Oct 2024 14:33:38 +0000

What even is Linux?

Linux is a family of free and open source operating systems based on the Linux kernel.

Although being completely free (unlike alternatives) Linux currently only has 4.5% of the global desktop operating system market, a very low percentage.

What makes Linux great?

The core difference between Linux and other mainstream desktop operating systems (windows, macOS) is the fact that it is free and open source. This allows it to be:

Highly performant - Linux is often faster and more efficient than its counterparts.
Free from spyware and ads - Unlike Windows 11 which is adding ads to the start menu
Arguably more secure - Being open source often makes it more secure
Endlessly customizable
Completely free forever - Because it is published under a free and open source GPL license.
and much much more

Read The importance of open source software for more information about open source software and it’s superiority.

If Windows and macOS are like apartments with rules and restrictions on what you can change, then Linux is like a house that you own that you can renovate, decorate and modify any way you like.

If Linux is so great why isn’t everyone using it?

We (all Linux users) can probably agree that the main drawback of Linux is user-friendliness. The average user never cared and will never care about what bootloader their laptop is using.

The fun part however is that most people are using Linux, they just don’t know it!

Android

Android is the most widely used mobile operating system in the world. With a staggering 71% of the global mobile operating system market

A lesser known fact is that android is based on the Linux kernel.

So basically 71% of smartphones are running Linux!

Servers

Linux is the leading operating system on servers (over 96.4% of the top one million web servers’ operating systems are Linux) It also leads other systems such as mainframe computers, and is used on all of the world’s 500 fastest supercomputers.

This website is being served from a Linux server.

The majority if not all of the websites that you visit every single day are being served from a Linux server.

IoT and embedded systems

Most IoT (Internet Of Things) devices run Linux because of it’s lightweight nature and robustness. This article from 2018 suggests that 71% of IoT devices run Linux

Most embedded systems (smart TV’s, routers etc) run Linux

Conclusion

Linux is quietly running behind the scenes. It may only capture a small slice of the desktop operating system market but it’s a huge player in mobile, server and IoT spaces. In fact a majority of people are using Linux daily without even realizing it! It’s in your phone, your favorite websites and countless devices around you.

Ultimately I highly recommend anyone interested to at least try and play around with Linux (especially if you are in the IT field I feel like it’s a must)

PS: this article was written on a Framework 13 running Fedora 40 (Linux)

Join my free newsletter

Here https://newsletter.4rkal.com/subscription/form

How to build a URL shortener in Go

4rkal — Sun, 22 Sep 2024 15:24:11 +0000

In this article I will be going through how to make a url shortener in go. The final result will look something like this shortr, source code

This is a great weekend project especially if you’re new to go.

What is a url shortener?

A URL shortener is a tool that takes a long URL and shrinks it down into something much shorter and easier to share. Instead of copying and pasting a long string of letters, numbers, and symbols, you get a compact version that leads to the same destination. For example, a long URL like www.somelongwebsite.com/articles/this-is-a-super-long-link could become something like bit.ly/abc123. It’s super handy for sharing links on social media, in texts, or anywhere space is limited. And most url shorteners provide analytics like link clicks.

Requirements

Go installed on your system.
A code editor, eg vs code, neovim

In this project I will be using echo as the http server and the standard html library.

Project Setup

Create a new directory to house our project

mkdir project-name
cd project-name

Assuming you have golang installed.

Create a new go module (project):

go mod init project-name

Before we start writing any code we first have to install echo:

go get github.com/labstack/echo/v4

Now create a new file called main.go

touch main.go

And open it in your favorite editor.

Creating url handlers

func main() {

    e := echo.New()

    e.Use(middleware.Logger())
    e.Use(middleware.Recover())
    e.Use(middleware.Secure())

    e.GET("/:id", RedirectHandler)
    e.GET("/", IndexHandler)
    e.POST("/submit", SubmitHandler)

    e.Logger.Fatal(e.Start(":8080"))

}

This will create three different routes/handlers.

The /:id, which will redirect the user to the required website

The / which will display a url submission form for new urls to be added

Finally the /submit which will handle url submissions from the form in /

Redirect Handler

The most important part of our application is the redirect handler, which will redirect the user to the url that was specified.

Before we create any urls we first have to declare some variables and make a helper function

In order to have a random ending to our url. eg /M61YlA, we will create a new function called GenerateRandomString

const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

func generateRandomString(length int) string {
    seededRand := rand.New(rand.NewSource(time.Now().UnixNano()))

    var result []byte

    for i := 0; i < length; i++ {
    index := seededRand.Intn(len(charset))
    result = append(result, charset[index])
    }

    return string(result)

}

This will select length random characters from the charset. If you want your slugs (urls), to not contain any capital letters, you can remove them from the charset.

Now we will need to have a place to store all of our links. In this example we will be storing them in memory and not a database.

Create a new struct called Link and a map called LinkMap:

type Link struct {
    Id string
    Url string
}

var linkMap = map[string]*models.Link{}

You can also add some sample data to it.

var linkMap = map[string]*Link{ "example": { Id: "example", Url: "https://example.com", }, }

Now we can (finally) create our RedirectHandler, which will handle all of the redirects for our url shortener.

func RedirectHandler(c echo.Context) error {
    id := c.Param("id")
    link, found := linkMap[id]

    if !found {
    return c.String(http.StatusNotFound, "Link not found")
    }

    return c.Redirect(http.StatusMovedPermanently, link.Url)
}

This function will get the id of the link eg /123 and will look for it in the global LinkMap, if it is not available it will return an error that the link was not found. Otherwise it will redirect the user to the specified url using a 301 Permanently Moved http response code.

Recap #1

The code so far should look something like this:

package main

import (
"math/rand"
"time"
"github.com/labstack/echo/v4"
"github.com/labstack/echo/v4/middleware"
)

type Link struct {
    Id string
    Url string
}

const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

var linkMap = map[string]*Link{ "example": { Id: "example", Url: "https://example.com", }, }

func main() {
    e := echo.New()

    e.Use(middleware.Logger())
    e.Use(middleware.Recover())
    e.Use(middleware.Secure())

    e.GET("/:id", RedirectHandler)
    //e.GET("/", IndexHandler)
    //e.POST("/submit", SubmitHandler)

    e.Logger.Fatal(e.Start(":8080"))
}

func RedirectHandler(c echo.Context) error {
    id := c.Param("id")
    link, found := linkMap[id]

    if !found {
    return c.String(http.StatusNotFound, "Link not found")
    }

    return c.Redirect(http.StatusMovedPermanently, link.Url)
}

func generateRandomString(length int) string {
    seededRand := rand.New(rand.NewSource(time.Now().UnixNano()))

    var result []byte

    for i := 0; i < length; i++ {
    index := seededRand.Intn(len(charset))
    result = append(result, charset[index])
    }

    return string(result)

}

Run the server

go run .

You might also want to install any missing dependencies:

go mod tidy

If you head tolocalhost:8080/example you should be redirected to example.com

Submission Handlers

We will now define two new routes inside of our main function

e.GET("/", IndexHandler)
e.POST("/submit", SubmitHandler)

These two handlers will handle the default page displayed in / which will contain a form that will be submitted to /submit in a post request.

For the IndexHandler our code will look something like this:

func IndexHandler(c echo.Context) error {
    html := `
        <h1>Submit a new website</h1>
        <form action="https://4rkal.com/submit" method="POST">
        <label for="url">Website URL:</label>
        <input type="text" id="url" name="url">
        <input type="submit" value="Submit">
        </form>
        <h2>Existing Links </h2>
        <ul>`

    for _, link := range linkMap {
        html += `<li><a href="https://4rkal.com/` + link.Id + `">` + link.Id + `</a></li>`
    }
    html += `</ul>`

    return c.HTML(http.StatusOK, html)
}

When we visit / a submission for will be rendered, to submit a new website. Under the form we will see all registered links from our Linkmap

PS it is not recommended that you use html like this. You should be separating the html file or using a library like templ.

The submission handler SubmitHandler should look something like this

func SubmitHandler(c echo.Context) error {
    url := c.FormValue("url")
    if url == "" {
        return c.String(http.StatusBadRequest, "URL is required")
    }

    if !(len(url) >= 4 && (url[:4] == "http" || url[:5] == "https")) {
        url = "https://" + url
    }

    id := generateRandomString(8)

    linkMap[id] = &Link{Id: id, Url: url}

    return c.Redirect(http.StatusSeeOther, "/")
}

This handler will take a url from the form that was submitted, do some (simple) input validation and then append it to the linkMap.

Final Recap

The code for our url shortener is:

package main

import (
    "math/rand"
    "net/http"
    "time"
    "github.com/labstack/echo/v4"
    "github.com/labstack/echo/v4/middleware"
)



type Link struct {
    Id string
    Url string
}

const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

var linkMap = map[string]*Link{"example": {Id: "example", Url: "https://example.com"}}


func main() {

    e := echo.New()

    e.Use(middleware.Logger())
    e.Use(middleware.Recover())
    e.Use(middleware.Secure())

    e.GET("/:id", RedirectHandler)
    e.GET("/", IndexHandler)
    e.POST("/submit", SubmitHandler)

    e.Logger.Fatal(e.Start(":8080"))
}


func generateRandomString(length int) string {
    seededRand := rand.New(rand.NewSource(time.Now().UnixNano()))

    var result []byte 

    for i := 0; i < length; i++ {
        index := seededRand.Intn(len(charset))
        result = append(result, charset[index])
    }

    return string(result)
}


func RedirectHandler(c echo.Context) error {
    id := c.Param("id")
    link, found := linkMap[id]

    if !found {
        return c.String(http.StatusNotFound, "Link not found")
    }

    return c.Redirect(http.StatusMovedPermanently, link.Url)
}


func IndexHandler(c echo.Context) error {
    html := `
        <h1>Submit a new website</h1>
        <form action="https://4rkal.com/submit" method="POST">
        <label for="url">Website URL:</label>
        <input type="text" id="url" name="url">
        <input type="submit" value="Submit">
        </form>
        <h2>Existing Links </h2>
        <ul>`

    for _, link := range linkMap {
        html += `<li><a href="https://4rkal.com/` + link.Id + `">` + link.Id + `</a></li>`
    }
    html += `</ul>`

    return c.HTML(http.StatusOK, html)
}



func SubmitHandler(c echo.Context) error {
    url := c.FormValue("url")
    if url == "" {
        return c.String(http.StatusBadRequest, "URL is required")
    }

    if !(len(url) >= 4 && (url[:4] == "http" || url[:5] == "https")) {
        url = "https://" + url
    }

    id := generateRandomString(8)

    linkMap[id] = &Link{Id: id, Url: url}

    return c.Redirect(http.StatusSeeOther, "/")
}

Closing words

This is a great small project if you are new to/learning go.

It can be very helpful if you extend beyond this tutorial. For example here are some other ideas that you can add to the project:

Enhance the input validation
Track link clicks + Statistics Page
Improve UI (html)
Dockerizing the application
++

I did all of those and my url shortener (called shortr) can be accessed under the url app.4rkal.com and the source code is here

Join my mailing list

Subscribe here: https://newsletter.4rkal.com/subscription/form

Deploy django to production

4rkal — Fri, 20 Sep 2024 08:54:29 +0000

I recently deployed my very own django application to production. The website is called videiro.com and was developed in django + HTML/CSS/JS + Tailwind.

Setup

I am using a debian 12 server which will expose my application via cloudflare tunnels. All of the static files are being served via nginx and the Django project is being ran by gunicorn.

In this guide I will show you how I set this up.

Preparing the Django project

The first thing you will have to do is open the settings.py and change the following

Debug = False
ALLOWED_HOSTS = ['yourdomain.tld']
CSRF_COOKIE_SECURE = True
CSRF_TRUSTED_ORIGINS = [
    'yourdomain.tld',
]

You should also change the SECRET_KEY to a long random string, that you should never share with anyone.

After that create a new file called .gitignore and paste the following:

db.sqlite3
*.pyc

This will make sure that the database is not uploaded to our server and that no pyc files are either.

Now you can upload your project to a new github repository (or gitea repository). If you don’t want everyone to have access to your source code make sure to set the repository as private.

If you want to make sure that your source code stays private I recommend you setup a selfhosted gitea instance, read Selfhost your own gitea instance - selfhosted, lightweight github alternative, to learn how to do that.

git init
git branch -M main
git add .
git commit -m "initial commit"
git remote add origin https://...
git push -u origin main

Now that you we have done that you should login to your server

Server setup

Before configuring anything make sure that you don’t allow any ssh logins with a password. Follow Securing ssh with Key-Based authentication to secure your server from those kinds of attacks.

ssh user@server.ip

Make sure that your packages are up to data

sudo apt update && sudo apt upgrade

Now install python, pip, git and nginx

sudo apt install python3 python3-pip git nginx

Now clone your project into your home directory.

git clone https://...
cd my-project

Once you’re in install the following:

pip install django django-crispy-forms whitenoise

Now try to run the project:

python3 manage.py runserver

if you get an error that a package is missing install it and re run.

Configuring gunicorn

Now we will setup gunicorn

First install it

pip install gunicorn

Now create a new file called gunicorn.service with your favorite text editor:

sudo vim /etc/systemd/system/gunicorn.service

And paste the following:

[Unit]
Description=gunicorn daemon
After=network.target

[Service]
User=YOURUSER
Group=www-data
WorkingDirectory=/home/YOURUSER/PROJECT
ExecStart=/path/to/gunicorn --access-logfile - --workers 3 --bind 127.0.0.1:8000 PROJECTNAME.wsgi:application

[Install]
WantedBy=multi-user.target

Change YOURUSER to your user.

To find the path to gunicorn run:

which gunicorn

And your project name is the name of the folder inside of your project that contains the settings.py file.

Now run the following commands to start and enable gunicorn (start on boot)

sudo systemctl daemon-reload
sudo systemctl start gunicorn.service
sudo systemctl enable gunicorn.service

Now if you head to 127.0.0.1:8000 you should see your project running.

But were not finished yet

Setting up nginx

Now we need to serve our static content via nginx.

First create a new file nginx configuration file with your favorite text editor:

sudo vim /etc/nginx/sites-available/PROJECT

Change PROJECT to whatever you want

Now paste the following content:

server {
    listen 80;
    server_name YOURDOMAIN;

    location /static/ {
    alias /var/www/staticfiles/;
    }

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Just change YOURDOMAIN to the domain that this will be hosted on.

Create a symbolic link to enable your website:

sudo ln -s /etc/nginx/sites-available/PROJECT /etc/nginx/sites-enabled/

Start and enable nginx:

sudo systemctl start nginx
sudo systemctl enable nginx

Setup static files

The first thing you will have to do is cd into your (django) project

cd project

Now run the following command:

python3 manage.py collectstatic

This will create a new folder called staticfiles

Now to set up the static files we have two options:

Change the user in /etc/nginx/nginx.conf to your user (less secure)
Copy over the staticfiles to /var/www/ (more secure)

I will be doing the 2nd option:

First create a new file called staticfiles in /var/www

sudo mkdir -p /var/www/staticfiles

Now copy over all of the staticfiles from your project there:

sudo cp staticfiles/* /var/www/staticfiles

Now cd into /var/www

cd /var/www

Change the ownership of all the files

sudo chown www-data:www-data staticfiles
sudo chown www-data:www-data staticfiles/*

Restart the nginx service:

sudo systemctl restart nginx

Now if you head to:

127.0.0.1

You should see your website running with all of the static files being served!

Exposing via cloudflare tunnels

Now to make your website publicly accessible.

To do this you will need a cloudflare account and a domain pointed to cloudflare.

First head to the Zero Trust Dashboard

Under Networks click on Tunnels and then Create a tunnel

Once created you should Install and run a connector, follow the instructions on the page for your specific setup.

After the connector is running you should click on the Public Hostname tab and Add a public hostname.

Now you should see something like this:

Fill in the info as I have. The service type should be HTTP and the url should be 127.0.0.1:80 or localhost:80

Now if you head to the domain that you specified you should see your app up and running.

Congratulations!

If you enjoyed this post and want to support my (mostly unpaid) work , you can donate here.

Join my free newsletter!

Join here

Selfhost your own gitea instance - selfhosted, lightweight github alternative

4rkal — Mon, 19 Aug 2024 16:21:15 +0000

In this article I’ll walk you through how you can run your own gitea instance. But first

What is gitea?

Gitea is a painless selfhosted Git service. It is written in Go and is extremely lightweight. I run a gitea instance on my Le Potato and it barely uses any resources.

Why use gitea (vs GitHub, GitLab etc)

I started running my own Gitea instance because I wanted a private place to host my Obsidian notes. I did not want to have them in a private GitHub repository since it’s not on my own hardware. GitLab is harder to spin up and has a lot of features that I do not need.

If you want an easy to spin up, private git service gitea is your way to go.

Setup

In this guide I will be using debian 12. The setup should be the same on any other distribution since we will be using docker.

Installing and setting up docker

The first thing you will need is docker installed on your system.

Install docker on debian

Also make sure to add your user to the docker group. This will allow you to run docker commands without sudo.

usermod -aG docker $USER

Now reboot

Docker-compose.yml

Once docker is installed. We have to get gitea up and running

First create a new directory. This will host our docker-compose file.

mkdir gitea

Then create/edit docker-compose.yml in your favourite text editor.

vim docker-compose.yml

Then paste the following content:

version: "3"

networks:
  gitea:
    external: false

services:
  server:
    image: gitea/gitea:latest
    container_name: gitea
    environment:
      - USER_UID=1000
      - USER_GID=1000
    restart: always
    networks:
      - gitea
    volumes:
      - ./gitea:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000"
      - "222:22"

You can change any of the default ports eg switching 3000 to 8000 can be done like this:

ports:
- "8080:3000"

You can setup gitea using a PostgreSQL or MySQL database. But at least for my needs a simple SQLite3 database is more than enough.

Since I want my repositories to still exist even if the container is deleted I will use named volumes. The configuration file with named volumes should look something like this:

version: "3"

networks:
  gitea:
    external: false

volumes:
  gitea:
    driver: local

services:
  server:
    image: gitea/gitea:latest
    container_name: gitea
    restart: always
    networks:
      - gitea
    volumes:
      - gitea:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000"
      - "222:22"

Starting the container and additional configuration

Now you can start the container by typing:

docker compose up -d

The -d flag will run it in detach mode. If you want to see the logs live you can remove it.

After docker is done pulling, gitea should be up and running.

Now open up:

localhost:3000 or yourserverip:3000

And you should see something like this:

Fill in all of the required information. Since I will be using my subdomain git.4rkal.com I set the server domain and gitea base url to that.

Here you will also have the option to enable sending emails for email verification and notifications. I will be enabling that by using a free (shitposting) email from cock.li.

After you have entered all the required info click on Install Gitea.

After the installation is complete you should be up and running

Make publicly accessible with cloudflare tunnels (optional)

I will be making my instance publicly accessible using cloudflare tunnels.

To do this you will need a cloudflare account and a domain pointed to cloudflare.

First head to the Zero Trust Dashboard

Under Networks click on Tunnels and then Create a tunnel

Once created you should Install and run a connector, follow the instructions on the page for your specific setup.

After the connector is running you should click on the Public Hostname tab and Add a public hostname.

Now you should see something like this:

Fill in the info as I have.

You can create a new subdomain eg git or gitea

The service type should be HTTP and the url should be yourserverurl:3000

Now if you head to the domain that you specified you should see gitea up and running.

In my case you can access my public gitea instance at git.4rkal.com

Congratulations, you now have your very own gitea instance!

If you enjoyed this article, consider supporting me

Improving Golang API request performance

4rkal — Sat, 17 Aug 2024 09:25:15 +0000

The project

I recently started working on a cryptocurrency exchange aggregator. Basically I send out requests to a bunch of different exchanges and compare rates. This has to be made as fast as possible. In this post, I’ll some show some tweaks that I made in order to boost my performance significantly.

However keep in mind that I am not an expert (especially in go) and I am just sharing my findings from my own personal project.

Improvements

These improvements come in order of biggest improvement of runtime.

1. Using goroutines

In any Go program, goroutines are essential for speed. The biggest boost I made was by sending requests concurrently. Since I need to hit up 12 different exchanges, sending these requests at the same time dropped my runtime from around 24 seconds to just ~3.

Goroutines are amazing and extremely easy to use. You should include them wherever possible. But always be careful of Data Races

2. Upgrading the JSON Library

I swapped out encoding/json for github.com/json-iterator/go.jsoniter is a fast JSON processing library that works as a drop-in replacement for the standard library, so I didn’t have to change any code, just a library switch.

Benchmark Results

To measure the performance improvements, I ran some benchmarks comparing encoding/json and jsoniter. Here’s a summary of the results:

goos: linux
goarch: amd64
pkg: apiSpeedImprove
cpu: AMD Ryzen 5 7640U w/ Radeon 760M Graphics      
BenchmarkEncodingJSON-12 140383 7381 ns/op
BenchmarkJSONIter-12 974605 1217 ns/op
PASS
ok apiSpeedImprove 3.216s

So, jsoniter is about 6 times faster than the standard library.

3. Reusing HTTP Handlers

I started reusing HTTP handlers instead of creating new ones for each request. By setting up a handler once and reusing it, I cut down on the overhead of making new handlers for each request.

Benchmark Results

Here are the results of the benchmarks comparing reused handlers versus creating new handlers for each request:

goos: linux
goarch: amd64
pkg: apiSpeedImprove/httpReuse
cpu: AMD Ryzen 5 7640U w/ Radeon 760M Graphics      
BenchmarkNewHttpClientEachRequest-12                3360            300058 ns/op
BenchmarkReuseHttpClient-12                         6470            175472 ns/op
PASS
ok      apiSpeedImprove/httpReuse       4.010s

Reusing HTTP handlers gave a slight performance boost compared to making a new handler for each request.

Conclusion

With these tweaks I managed to cut the time it took to gather all the info from 24 seconds initially to about 2 seconds. Pretty solid improvement!

If you are interested the code for my benchmarks, it is available here

If you enjoyed this post and want to support my work, you can donate here.

My Obsidian + Hugo blogging setup

4rkal — Tue, 13 Aug 2024 14:15:57 +0000

If you clicked on this article you probably know what these two technologies are but if you don’t here’s a quick explanation:

Obsidian

Obsidian is a feature packed markdown editor. But it’s not just a markdown editor. It’s a way to manage knowledge. It’s great for organizing your thoughts in a flexible, non-linear way.

Obsidian works on all platforms. So you can write articles from basically any platform.

I have been taking all of my notes in it for a couple of months now and it’s amazing!

Hugo

Hugo is an ultra fast static website generator made in golang. I have been using hugo for my blog for almost 2 years now. I recently switched the theme of my my blog. Read more about the change New Look, new start.

Setup

In this article I will not be showing how to setup these two technologies but merely how to get them to work together.

If you wan’t to learn how I setup this whole blog using hugo, cloudflare and render.com read:How I setup this blog for free (domain, hosting, ssl) Complete Guide

If you wan’t a good guide on how to use obsidian read:Getting started - obsidian.md

Goals

My goals for the setup are:

Using a single obsidian vault
Have an easy to use obsidian template that I can use for my blog posts.
Keep my personal vault folders private.
Auto publish using obsidian hotkeys.
Have all markdown files in a public github repository, so that people can propose changes

Existing setup

The way that my current work flow works is:

Edit articles from the content folder.
Run hugo command.
Push to github.
Render.com automatically picks up the changes and serves them.

Journey

If you want to skip the journey part you can go straight to The Sauce

I will be going through a couple of mistakes that I made while setting this up.

Mistake #1

The first idea that I had was to create a simple symlink (I use linux btw) that would link the two folders together.

Basically I have two folders:

blog/
vault/

The blog folder contains all the blog folders and the vault is my personal vault.

The symlink would link these folders

blog/content
vault/Blog

However the problem with a symlink is that the folder content is not visible in my git repo. This means that people can not propose changes to any of my articles

Mistake #2

I wanted to have my folders synced. I tried writing a couple of bash scripts that automatically synced the two folders using a cronjob. However having that constantly running the background is a waste of resources when I am not writing. Simply running the scripts via cli is just not that smooth.

The Sauce

Basically the way that I have set this up is I have two folders:

blog
vault

The blog folder contains all the necessary hugo files and also has a sub directory called content that houses all of the markdown blog files.

I created a new folder inside of my vault called Blog

blog/content
vault/Blog

After that I copied over all of my files from the content directory to the Blog.

I then started writing this very article

Obsidian templates

I needed some way to setup a simple template to contain all of the required hugo front matter.

That is quite easy.

Read about how to setup templates Templates - obsidian.md

I created a file called Blog Post in my templates folder

My Blog Post template contains the following:

---
title: "{{Title}}"
description: 
date: "{{date:YYYY-MM-DD}}T{{time:HH:mm:ss}}+00:00"
draft: true
---

**If you enjoyed this article consider [supporting me](https://4rkal.eu.org/donate)**

I have all the required front matter including a title, description and a date in the format that hugo asks.

I also added a small donation text that I include at the bottom of every article.

This means that I can automatically insert this template into any file and start writing!

Folder Syncing

Now I want all of my files in my vault/Blog directory to be copied over to the blog/content

Thank’s to a helpful discord user I found the obsidian-shellcommands plugin.

NOTE: this plugin does not currently work very well with the flatpak version of obsidian (since flatpak isolates the environment) . Using another alternative (.deb or appimage) seems to work.

It allows you to run shell commands in the background with a hotkey.

The steps to set this up are the following:

Install the plugin
Enable the plugin
Go to the plugin options
Click on New shell command
Now you will need to enter a shell command to copy the files from the one folder to the other.

On Linux/MacOS that is:

cp -a ~/folder1/. ~/folder2/

in my case that is cp -a ~/Documents/vault/Blog/. ~/Documents/blog2/content/

On windows it most probably is:

robocopy "%USERPROFILE%\folder1" "%USERPROFILE%\folder2" /E /COPYALL

After that we need to set a hotkey that will run the command

Click on the (+) icon to go to the hotkey settings and assign a hotkey

My hotkey is CTR + 0, simply because that was available.

Now every time that I run the hotkey it copies over all of my files to the hugo folder ready to be published

Auto publishing scripts

I also want to be able to automatically publish my articles. But I want it to happening by hitting a hotkey.

I wrote a small script that does exactly that:

#!/bin/bash
cd ~/Documents/blog

hugo

git add .
git commit -m "new"
git push -u origin main

This script will build my website, commit and push to my github repo, where it is picked up and published. Read How I setup this blog for free (domain, hosting, ssl) Complete Guide to learn how to setup your own blog for free.

Don’t forget to make the script executable by running

chmod +x ./YOURSCRIPT.sh

Then create a new shell command for the shellcommand plugin (as we did before) and enter the path to your script.

In my case that is:

~/Documents/blog2/push.sh

Then enter a hotkey and you’re done!

Conclusion

I can now simply open my obsidian vault, create a new file, insert my template and have all the info automatically entered.

I then write my article inside of obsidian

Run my hotkey and copy all the files into the hugo directory

Hit another key and my blog is published!

If you enjoyed this article consider supporting me

Ultimate Monero ColdStorage Guide (Feather X Anonero)

4rkal — Thu, 14 Dec 2023 18:00:30 +0000

In this comprehensive guide, I will walk you through the process of easily setting up Monero cold storage using an old computer and your smartphone, using animated QR codes. No USB needed!

Requirements

An old laptop/computer with a webcam (to be kept offline). Called offline or cold computer.
An android smartphone.
Your main computer

Required reads

Before starting this article you must read:

Cold computer setup

Your offline computer/laptop will be signing all of the transactions. It should always be kept offline i.e cold. It can not be used for other tasks.

I highly recommend that you use a linux distribution and NOT windows for cold storage. Linux is free and opensource. I highly recommend pepermintOS or MX linux as they are lightweight and pretty easy to setup.

I will not be guiding you on how to install [[linux]]. But here are some resourses to help you get started:

Installing PeperMintOS <– somewhat 32 bit support, lightweight
Installing LinuxMint <– better for newer computers
Installing MX Linux <– 32 bit support, pretty lightweight

Downloading & Installing necessary software

The first thing that we will need to do is download the required software.

We will need featherwallet

and that’s about it.

Taking the device offline

It is highly recommended that you disable the wifi and bluetooth modules on your cold computer. This can be by physically detaching the wifi and bluetooth module or disabling it in the bios. The later is less secure if you’re going full on tinfoilhat.

Here’s a guide on how to physically disable them from malvarma.org

A guide on how to disable it via BIOS can be found by searching your specific hardware on your favorite search engine.

Computer cold wallet setup

Now we will have to setup our wallet. Ensure that your device is completely offline and then open featherwallet.

Click on Create a new wallet. Then click on Next. You will be presented with your seedphrase. Write it down!! on physical paper.
Select a name for your wallet and click Next
Select a wallet password and click Next.
Now that the wallet is open in the bottom right corner there will be a dot. Click on it and select the offline box and then click Disable all network connections (offline)

Phone

We will now be installing the anonero software. We will be using NERO from the ANON/NERO suite.

Download and install fdroid. Apk can be downloaded from the F-Droid website
Download and install orbot. Can be installed from google play store here
Open orbot. Select VPN Mode, click on the onion logo that says start
Open fdroid and in the settings scroll down and enable Use Tor option
Again in the settings that click on the repositories section and add the following:
Click on latest and then search for NERO
Click on install That’s it ; )

Updating NERO

If you want to update NERO you will have to turn orbot on, open fdroid and refresh the updates tab

NERO setup

To set up NERO, follow these steps:

Once NERO is successfully installed, open the application.
Click on RESTORE WALLET option and select RESTORE FROM KEYS
Proceed to establish a node connection. You can find a lot of Monero nodes here.

Copy the node address into the node field. By default you shouldn’t need a username or password

By default tor connectivity is enabled in NERO. You can disable it by going into the proxy settings and deleting everything.

Click on Connect. It will try connecting. If it fails check your internet connection or try another node

Importing view-only wallet

Now you will have to import your wallets Primary address , Secret-View key and Restore height into NERO. To import that info to nero:

On your offline computer open featherwallet and navigate to Wallet then View-Only. Enter your password and click on the Show QR

Now in nero in the View only keys screen click on the square icon to scan the qr. Then scan the qr displayed by featherwallet. All the info should be filled in after scanning the qr code. Click Next.

Set a pin. After that your wallet should be imported into NERO.

Receiving monero

To receive monero you can follow these steps

Open NERO and enter your pin
Click on the receive tab (the one with the qr code icon)
Long hold on the address
Select one of the SubAddreses and click on the copy icon.
Transfer any amount of monero to that address.

After 10 confirmations it should be spendable. Proceed to the next step.

Signing transactions

Signing/Broadcasting transactions is easy with the NERO/Feather duo. No usbs are needed it is all done via animated QR codes.

To sign/broadcast a transaction follow these steps On your phone:

Open NERO and enter your pin
In the send tab enter the desired address and amount
Click on continue, you should now see an animated QR code.

On your cold computer

Open feather and enter your password
Click on Tools > Offline transaction signing. You should now see your camera
Show your phone to the computers camera so that it can read the QR code.
After it has been picked up by your computer you should see a QR code displayed on your computers screen

In NERO.

Click on SCAN KEY IMAGES
Scan the QR code from the computer’s screen
Once it has been picked up you can see the Address, Amount, Fee and Total. Click on confirm
You should now see the unsigned TX screen.

In feather click on Next. Then scan the QR code displayed by NERO to your computer. Once the bar is at 100%, you should again see the Address, Amount, Fee and Total. If your ok with that click on SIGN.

In NERO

Click on SCAN SIGNED TX
Scan the QR displayed by feather wallet.
Click on Yes, once asked whether or not to broadcast transaction

You have now sent the transaction.

if this article helped you out consider supporting me

SSH Remote Access NO Port-Forwarding NO Cloudflare

4rkal — Wed, 04 Oct 2023 16:17:04 +0000

In this article I will show you how I securely connect to my remote machines without having to configure port forwarding.

Requirements:

A computer “server” (running linux)
A internet connection
Another computer to connect to your server (running linux)

Why?

If you want to access your server without portforwarding in a extremely secure fashion you will want to follow this tutorial. You will be connecting to the server via tor which will make it harder for anyone to find the url of the server and ill show you how to setup keybased auth for even more security!

Setup

You will have to install the following packages (ssh, tor)

On debian

sudo apt install openssh-client

On arch

sudo pacman -S openssh

After that enable the ssh service

Debian:

sudo systemctl enable ssh

Arch:

sudo systemctl enable sshd

If you want to check if this worked just use another computer and run

ssh USER@IP

for example I run

ssh arkal@192.168.1.69

After this you can enable KeyBased authentication for more security

Here is my article how to enable that :

Enable keybased authentication

Now we need to install tor:

On debian

sudo apt install tor

On arch

sudo pacman -S tor

Then start and enable the tor service with

sudo systemctl start tor && sudo systemctl enable tor

After you have done that you want to edit your torrc file. Using your favorite text editor

sudo vim /etc/tor/torrc

Now you will want to navigate to the part that says HiddenService. And paste the following

HiddenServiceDir /var/lib/tor/ssh/
HiddenServicePort 22 127.0.0.1:22

Save your file and exit the editor (for nano cntrl s, cntrl x)

Now you want will have to restart the tor service

sudo systemctl restart tor

After that run the following:

sudo cat /var/lib/tor/ssh/hostname

You should see a string of letters and characters ending in .onion

Now on your other machine:

Connecting to the server

On your main machine you will have to do the following:

Have ssh, tor, and socat installed

After you have installed them you will have to edit the ssh config

vim .ssh/config

And paste the following

Host NAME
 Hostname URL.onion
 User USER
 Port 22
 Proxycommand socat - SOCKS4A:127.0.0.1:%h:%p,socksport=9050

You will have to change the NAME, URL and USER. The user is the user you want to connect as to your server and the url is the url you that ends in .onion from above.

Now save the file and exit.

Now edit the torrc file. Using your favorite text editor:

vim /etc/tor/torrc

Find the line that says SOCKSPort and uncomment it

SOCKSPort 9050

Restart the tor service

systemctl restart tor

To connect to the server run the following command:

ssh NAME

With NAME being the name that you gave to the server in the config file.

If this article helped you out consider supporting me

Python for Complete Beginners

4rkal — Mon, 06 Mar 2023 17:52:42 +0000

Why you should use Python. Going over the basics of Python.

In this course/article I will be talking about why someone should use Python. Later on, I will be tackling the basics of Python. But let’s start by explaining what coding is.

What is coding?

Coding means writing instructions for computers and a finished set of instructions is known as a program. Computer programs control everything from smartphones to space rockets.

What is Python?

Python is a text-based computer language which means it’s made up of words and symbols (such as * and = ). Its language elements and object-oriented approach are meant to assist programmers in writing clear, logical code for both small and large-scale projects.

Why Python?

Python is one of the most popular computer languages and it’s very concise — that is, you don’t need to type much in order to create programs that do a lot.

Advantages of python

Simple to read, learn, and write

Python is a high-level programming language with a syntax that is similar to English. This makes the code easier to read and comprehend.

Python is really simple to pick up and understand, which is why many people suggest it to newcomers. When compared to other prominent languages like C/C++ and Java, you require fewer lines of code to accomplish the same purpose.

Improved Productivity

Python is an extremely useful programming language. Python’s simplicity allows developers to concentrate on solving the problem.

They don’t need to spend a lot of time learning the programming language’s syntax or behaviour. You write less code and accomplish more.

Free and Open-Source

Python comes under the OSI-approved open-source license. As a result, it is both free to use and distribute. You can get the source code, change it, and even share your own Python version.

Portability

In many languages like C/C++, you need to change your code to run the program on different platforms. With Python, however, this is not the case. You only have to write it once and it may be used wherever.

Downloading Python

On Linux You probably already know how to install it but I’m gonna show it anyways.

Open your terminal and type python or python3; if it does not work then run: (depending on your distro)sudo apt install python3

Windows 10 1 . First check if you already have Python installed. Go to the ‘Start’ menu and click on the ‘All programs’. If you see the word “Python” it means that you already have it installed. If you don’t already have it installed go to https://python.org, download the correct version for your computer and then install it.

Python comes in different versions. This course uses version 3 and upwards. I recommend always installing the latest version.

What is an IDE?

IDE stands for the integrated development environment (IDE) and is software for building applications that combine common developer tools into a single Graphical User Interface (GUI).

The IDE that we will be using in this series is called VS Code.

Downloading VS Code

Go to https://code.visualstudio.com/ and download the version that you want. Vs Code is available for Windows, Mac, and Linux. Follow the instructions on the website for installation.

Starting in Python

It’s traditional in the programming world to make the computer say ‘Hello World’ with your very first piece of code. In Python, this is very simple.

Open Vs Code and click on File > New File and name your file helloworld.py. The .py tells the computer that this is a Python program.
In your project, in VS Code type :print("Hello World!")
Save your project and click on the run button at the top of your screen
If you have done everything correctly you should see a Hello World message in your terminal.

If it didn’t work you should get a red error message something like this:

SyntaxError: invalid syntax

If that happens make sure that you have copied it exactly like above.

Playing With numbers in Python

Python makes it easy to do maths. You just type in a question and get the answer

Adding Up

Open an empty project and type:

print(2+2)

You should see the answer:4

Subtracting(and more)If you want to subtract, use the ‘-’ symbol like this:

print(2 - 2)

To multiply use the ‘*’ symbol:

print(2 * 2)

To divide, use the ‘/’ symbol

print(2 / 2)

Variables

A variable is like a labelled box that stores information. You can change this information but the label stays the same.

Creating a variable:

To tell the computer what you want your variable to be, you use the = sign. This is called assigning a value to a variable. It’s very simple, here’s an example using fish.

Open a new VS Code project and type:fish = 5

Imagine a cat gets hungry and eats two fish. To create another variable for the amount eaten, write the following:

fishEaten = 2

Press enter and then type:

print(fish - fishEaten)

Save and run your code and you should get the answer:3

Input in Python

You can use the input() function to ask for information from the user.

Open a new VS Code project and type:

name = input("What is your name? ")

Run the program and you should get the following message:

What is your name?3. Now let’s try printing your name.

Add the following to your program:

print(name)

You have successfully created an input field!

This can be very useful in creating decision games.

Making Decisions

To write a program that allows you to make decisions the computer needs to react differently to different answers. For this, you need conditions to compare pieces of information, and conditionals to create different paths through the program.

What are Conditions?

A condition is a bit of code that compares two pieces of information. Conditions use operators to make these comparisons. For example, the operator == checks if two pieces of information are the same.

Open a new Vs Code project and type:

age = 10
if age == 12:
 print("True")
else:
 print("False")

Save and run and you should get False

That is because ‘age’ is set to 10 and not 12

What are conditionals

To use a condition in your code you need a command called a condition. Conditionals use conditions. Conditions show if something is True or False.

IF

One important condition is known as an if statement which tests whether a condition is true. If it is, the computer will follow the instructions after the if statement. If not, the computer will just skip it. In Python, if is a keyword. Dont use it as a variable name because the computer will think that it’s an if statement and get confused.

Implementing the if condition

Create a new VS Code project and type the following:

user_reply = ("Do you like python? (Type yes or no) ")

Then we will implement the if condition by typing the following:

if user_reply == "yes"
   print("Python likes you to ! ")

ELIF

elif is short for else if. If the conditions of the if code isn’t met it “sweeps up” whatever is left.

Now type the following:

elif user_reply == "maybe":
  print("Make up your mind!")

ELSE

When conditions for the if and elif code arent met, else goes into action and “sweeps up” whatever is left.

Let’s implement that: 4. Now type the following:

else:
  print("Well python doesn't like you either")

The complete code should look something like this:

user_reply = ("Do you like python? (Type yes or no) ")
if user_reply == "yes"
   print("Python likes you to ! ")
elif user_reply == "maybe":
  print("Make up your mind!")
else:
  print("Well python doesn't like you either")

Don’t forget to press the tab after if statements.

Randomness in python

In python we can use the random function in order to generate random numbers. This can be extremely useful in a variety of things.

The first thing we will have to do is import the random function

import random

After that we can print out a random number with the following

print(random.randint(1,10))

This will output a random number from 1–10

randint stands for random integer.

Here is the full code.

import random
print(random.randint(1,10))

Loops in python

There are two types of loops in python

While loop
For loop

While loops only stop when something changes. If it doesn’t change they could go on forever.

With for loops on the other hand you can define exactly when you want them to stop

The most popular example of a while loop is

while True:

Which will run forever eg

while True:
    print("hi")

This will run forever.

With while loops on the other hand you can define exactly how many times you want the loop to run.

for x in range(0,10):
   print("Hi")

This will print Hi exactly 10 times

Guessing game

Now lets combine what learned from above and from our previous articles to create a game

The computer will select a random number from 1–10 and you will have to guess it.

The first thing we will have to do is

import random

After that we will create a variable called number

number = random.randint(1,10)

After that we will create another variable called your_guess

your_guess = int(input("Im thinking of a number from 1 to 10, can you guess which one?"))

We are using int as you will have to enter a number

Now we will create a while loop that will keep the game running until you guess the number

while your_guess != number:

The code so far is

import random
number = random.randint(1,10)
your_guess = int(input("Im thinking of a number from 1 to 10, can you guess which one?"))
while your_guess != number:
    if your_guess < number:
        print("Your number was too low")
    else:
        print("You number was to high")

And the following

print("GG you found it")

You code should now look like this

import random
number = random.randint(1,10)
your_guess = int(input("Im thinking of a number from 1 to 10, can you guess which one?"))
while your_guess != number:
    if your_guess < number:
        print("Your number was too low")
    else:
        print("You number was to high")
    your_guess = int(input("Please try again... "))
print("GG you found it")

Thats it for now

Stay tuned for more

If you enjoyed this article consider supporting me

PocketBase self-hosted Firebase alternative

4rkal — Mon, 06 Mar 2023 17:44:46 +0000

What is PocketBase

PocketBase is an open source backend made in go consisting of embedded database (SQLite) with realtime subscriptions, built-in auth management, convenient dashboard UI and simple REST-ish API.

Install PocketBase

The first thing that you will have to do is head to https://pocketbase.io and select the file for your operating system. Since I am using linux I will show how to set this up on linux but it should be pretty similar for any other os.

Unzip the file and open up a terminal to the path that you extracted the file to and type:

./pocketbase serve

If you want to serve some static content you can create a new directory called pb_public

mkdir pb_public

Then paste any content into that directory

eg.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Epic Website</title>
</head>
<body>
    <h1>My epic website</h1>
</body>
</html>

And save that as index.html inside of the pb_public folder

Now if you head to http://127.0.0.1:8090/ you should see the website that we entered above.

If you go to http://127.0.0.1:8090/\_/ it will take you to an admin portal. There you should create a account. After you have setted up your account you should see something like this.

Here you can add and create users

And also create custom collections eg

If you click on the settings icon you can see that you will be able to add applications, mail settings, file storage (s3) , export/import collections, add or remove auth providers, token options and add/remove admins.

That’s it for now if you want to learn more check out https://pocketbase.io/docs/

If you enjoyed this article consider supporting me

DEV Community: 4rkal

Prevent newsletter signup spam

Backstory

What I learned

How I fixed it

Step 1: Enable Double Opt-in

Step 2: Add Captcha or Cloudflare JS challenge

Summary

Deploying Go + Templ + HTMX + TailwindCSS to production

Setup

The setup

Tailwind

Server

Nginx

Cloudflare Tunnels

Deployment

Join my free newsletter!

Related Articles

If Linux is so great why isn't everyone using it?

What even is Linux?

What makes Linux great?

If Linux is so great why isn’t everyone using it?

Android

Servers

IoT and embedded systems

Conclusion

Join my free newsletter

How to build a URL shortener in Go

What is a url shortener?

Requirements

Project Setup

Creating url handlers

Redirect Handler

Recap #1

Submission Handlers

Final Recap

Closing words

Join my mailing list

Deploy django to production

Setup

Preparing the Django project

Server setup

Configuring gunicorn

Setting up nginx

Setup static files

Exposing via cloudflare tunnels

Join my free newsletter!

Selfhost your own gitea instance - selfhosted, lightweight github alternative

What is gitea?

Why use gitea (vs GitHub, GitLab etc)

Setup

Installing and setting up docker

Docker-compose.yml

Starting the container and additional configuration

Make publicly accessible with cloudflare tunnels (optional)

Improving Golang API request performance

The project

Improvements

1. Using goroutines

2. Upgrading the JSON Library

3. Reusing HTTP Handlers

Conclusion

My Obsidian + Hugo blogging setup

Obsidian

Hugo

Setup

Goals

Existing setup

Journey

Mistake #1

Mistake #2

The Sauce

Obsidian templates

Folder Syncing

Auto publishing scripts

Conclusion

Ultimate Monero ColdStorage Guide (Feather X Anonero)

Requirements

Required reads

Cold computer setup