Pod timto textem nasleduje prehled odkazu – od diskuznich for po moderni aplikace.

Uzitecny internetovy проект - https://celostnilecba.com/faq/proces-formalizace-jazyka-v-informatice
Tato stranka nabizi sirokou skalu informaci a materialu pro bezne uzivatele. Clanky jsou dobre strukturovane, takze navstevnici vzdy dostanou aktualni data.

Prakticke webove utility - https://podhradem.net/sbirkytipu/televize-samsung-vysila-slaby-signal-co-delat
Nabidka praktickych nastroju pro kazdodenni praci i zabavu. Nastroje jsou intuitivni a snadno ovladatelne.

Server s aktualnimi zpravami - https://arabiavacation.com/zkusenosti/odevzdani-prvniho-radku-v-excelu-jednoduche-zpusoby
Zdroj aktualniho zpravodajstvi a zajimavosti ze sveta i domova. Struktura webu je logicka, coz usnadnuje vyhledavani konkretnich temat.

Progressivni online projekt - https://deponativ.info/zacatecnici/jak-vyrobit-reminek-na-hodinky-z-prave-kuze
Web nabizi moderni reseni a prehledne rozhrani. Skvele reseni pro moderni dobu.

Zajimava iniciativa - https://arabiavacation.com/napady/kde-v-dubnu-odpocivat-v-egypte
Komunitni stranka sdruzujici lidi se stejnymi zajmy. Uzivatelska zakladna je aktivni, coz vytvari unikatni atmosferu.

Popularni internetovy portal - https://tvprodukce.com/overeno/jak-zakazat-oznameni-telegramu-na-obrazovce-android
Web s dlouhou tradici a tisici dennich navstevniku. Nabizi kombinaci zpravodajstvi a zabavy.

Uzitecny web do kapsy - https://celostnilecba.com/faq/prislovi-kde-je-tenko-tam-a-trha-se-vyznam-a-priklady-pouziti
Prakticky pomocnik do kapsy. Prinasi rady a navody krok za krokem.

Online platforma pro inspiraci - https://arabiavacation.com/krokzakrokem/jak-krmit-hrozny-pred-kvetem-pomoci-lidovych-prostredku
Misto, kde najdete nove podnety pro sve projekty. Uzitecne pro designery, marketery i kreativce.

Originalni web na siti - https://arabiavacation.com/krokzakrokem/pocet-linek-pci-express-na-procesoru-vse-co-potrebujete-vedet
Stranka s netradicnim pristupem k poskytovani obsahu. Autori dbaji na kvalitu a originalitu.

Kvalitni odborny zdroj - https://tvprodukce.com/seznamynapadu/prodlouzeni-doby-zhasnuti-obrazovky-pocitace-5-ucinnych-zpusobu-jak-usetrit-energii-a-prodlouzit-zivotnost-zarizeni
Odborny portal pro pokrocile. Urceno pro lidi, kteri chteji jit do hloubky.

Statisticky prehled online - https://podhradem.net/rady/jednoduche-a-efektivni-zpusoby-jak-rozzarit-obrazovku-na-androidu-samsung
Prehledne zobrazeni dat, statistik a grafu. Kvalitni podklad pro rozhodovani.

Sluzba pro moderni uzivatele - https://podhradem.net/jednoduche/jak-vycistit-optigril-tefal
Inovativni pristup k online sluzbam, ktery setri vas cas. Jednoducha registrace a okamzite vysledky.

Unikatni internetovy projekt - https://celostnilecba.com/praxe/jak-spravne-chranit-tulipany-a-narcisy-pred-chladem-a-mrazem-v-zime
Web, ktery vas nalaka na prvni pohled. Nabizi unikatni nastroje a funkce.

Online aplikace pro produktivitu - https://deponativ.info/otazky/jak-zkontrolovat-zapalovaci-civku-aveo-t300-multimetrem
Skvely pomocnik pro zvyseni produktivity prace. Vyhodnoti vas cas a navrhne zlepseni.

Tip na zajimavy web - https://tvprodukce.com/zapamatovat/sijeme-damskou-kosili-s-vlastnimi-vzory
Posledni polozka v nasem seznamu, ktera si zaslouzi vasi pozornost. Univerzalni obsah pro vsechny generace.

Tato kolekce stranek bude skvelym zakladem pro praci i zabavu. Pokud hledate overene zdroje, jednoznacne navstivte nase doporuceni. Prejeme prijemne surfovani!

[url=http://forums.hrsrevamped.com/viewtopic.php?t=150205]Prehled uzitecnych internetovych stranek, ktere musite videt c88vfc[/url] fc275ef

http://forums.shlock.co.uk/viewtopic.php?f=2&t=449977
http://w.mannlist.com/viewtopic.php?t=62513901
http://forums.shlock.co.uk/viewtopic.php?f=2&t=449976
http://apcboard.com/quote-1.html
http://www.gm878.com/forum.php?mod=viewthread&tid=306&pid=41768&page=24&extra=page%3D1

https://celostnilecba.com/triky/jak-pripojit-chytre-hodinky-k-androidu-samsung
https://deponativ.info/otazky/jak-se-spravne-zbavit-ikony-tipy-a-triky
https://celostnilecba.com/tipy/co-je-supinator-v-botach-a-proc-je-potreba
https://celostnilecba.com/tipy/datum-vydani-operacniho-systemu-windows-10
https://deponativ.info/postupy/ucinky-vyzivy-proteinem-misto-bezneho-jidla-pro-telo
https://deponativ.info/zacatecnici/jak-obnovit-rozpadajici-se-bios-na-notebooku-podrobny-navod
https://arabiavacation.com/zkusenosti/co-je-lepsi-pro-vykaly-sterk-nebo-sut
https://deponativ.info/recenze/jak-se-zbavit-vlhkych-sten-v-dome
https://deponativ.info/recenze/jak-nastavit-notebook-uzitecne-tipy-a-pokyny
https://arabiavacation.com/napady/co-se-stane-kdyz-upustite-iphone-7-na-podlahu
https://podhradem.net/sbirkytipu/cim-oblozit-verandu-v-soukromem-dome-venku-prakticka-a-stylova-reseni-pro-vytvoreni-utulneho-prostoru
https://deponativ.info/postupy/ve-snu-se-mi-zdalo-o-neobvyklych-podminkach
https://tvprodukce.com/overeno/jaky-by-mel-byt-pocet-hodin-telocviku-ve-skole-v-dnesnim-svete
https://deponativ.info/otazky/jak-zkontrolovat-penize-metody-a-tipy
https://podhradem.net/rady/gpon-mgts-pristup-k-routeru

[url=https://forum.dylzo.ru/topic/60855-consultant-x95lwx/]consultant x95lwx[/url] fbfdfc2

Golang is a programming language created by Google. It is a statically typed language with syntax similar to that of C. It is open source and available for download.

One of the main features of Golang is that it is a compiled language, which means that it is converted into machine code that can be run on a computer. This makes Golang programs very fast and efficient.

However, Golang is not without its errors. One of the most common errors that occur in Golang is the "undefined: X" error. This error occurs when a variable or function is used that has not been defined.

There are a few ways to fix this error. The first is to simply define the variable or function that is being used. The second is to use a type assertion to convert the variable to the correct type. The "undefined: X" error can be frustrating, but it is relatively easy to fix.

What is an error in Go?

Error is a built-in type in golang. It is used to represent an error condition, and is used to indicate failure of an operation. Errors are represented by the built-in type error. The built-in type error is a struct type with a single field, error, of type string. The error field is a string that describes the error.

An error in Go is defined as a value that implements the error interface. The error interface is a built-in interface in Go that is defined as follows:

type error interface {
    Error() string
}

The error interface is used to indicate an exceptional condition that has occurred. When an error occurs, it is often useful to have some context about what caused the error. The Error() string method provides that context.

The most common use of errors is to handle exceptional conditions when parsing text or binary data. For example, when reading a JSON document, a well-formed document must be encountered. If the document is not well-formed, an error will be returned.

Another common use of errors is to handle unexpected conditions when executing a program. For example, if a program tries to open a file that does not exist, an error will be returned.

In general, if a program encounters an error, it should be handled gracefully and not panic.

How to return an error in Go?

The Go programming language has built-in support for returning errors from functions. When a function returns an error, it is generally the last return value. The error type is a built-in interface:

type error interface {
    Error() string
}

An error can be returned in any case where a regular value would be returned. When the os.Open method fails to open a file, for example, it gives an error:

f, err := os.Open("filename.ext")
if err != nil {
    // handle error
}
// use f

The err != nil check is a common idiom in Go code. It is used to test whether the value of err is an error value or not. If it is, the code in the if block is executed.

There are many ways to create an error value. The most common is to use the New function from the errors package:

err := errors.New("something went wrong")

This creates an error with the message "something went wrong". Another common way to create an error is to use the fmt.Errorf function:

err := fmt.Errorf("something %s", "went wrong")

This creates an error with the message "something went wrong". The %s is a format specifier that will be replaced with the value of the "went wrong" string.

Once you have an error value, you can return it from a function like any other value:

func doSomething() error {
    // ...
    return fmt.Errorf("something went wrong")
}

If you want to return an error and a regular value from a function, you can use the multiple assignment idiom:

func doSomething() (string, error) {
    // ...
    return "", fmt.Errorf("something went wrong")
}

This idiom is often used when a function needs to return both an error and a result.

There are many functions in the Go standard library that return errors. For example, the os.Open function returns an error when it fails to open a file. When writing your own code, you should return errors wherever it makes sense to do so.

Rclone is a command-line program to manage files on cloud storage. It is a feature-rich alternative to cloud vendors' web storage interfaces. Over 40 cloud storage products support rclone including S3 object stores, business & consumer file storage services, as well as standard transfer protocols.

https://rclone.org/#about

Rclone shipped as a command-line program and is easy for the end users to configure and run.

But what if you want to use the Rclone feature in your Golang project? Luckily, Rclone was written in Golang and it’s possible for us to directly use Rclone API in our project.

In this post, I will demonstrate the usage of the Rclone API to handle file uploading.

Assume that we already have an api that receives the Multipart form request, this api will take the request and expose a *multipart.FileHeader for us to use in the next step.

Because Rclone support lots of Storage Provider and we may want to use these providers in our code, we will need to create an abstract interface for the future implementation.

Define the type and interface

import (
	"context"
	"github.com/rclone/rclone/fs"
	"github.com/rclone/rclone/fs/object"
)

type FileInfo struct {
	Disk string `json:"disk,omitempty"`
	Path string `json:"path,omitempty"`
	Type string `json:"type,omitempty"`
	Size int    `json:"size,omitempty"`
}

type Disk interface {
	Name() string
	Url(filepath string) string
	Delete(c context.Context, filepath string) error
	Put(c context.Context, in io.Reader, size int64, mime, dst string) (*FileInfo, error)
	Multipart(c context.Context, m *multipart.FileHeader, dsts ...string) (*FileInfo, error)
}

type RcloneDisk struct {
	fs.Fs
	DiskName string `json:"name"`
	Root     string
}

func (r *RcloneDisk) Name() string {
	return r.DiskName
}

• Disk is an interface that we will use later
• FileInfo holds the uploaded file information
• RcloneDisk is a base implementation of the Disk interface, the future disks we create will extend from this base

Take a look at Rclone Fs interface and we have this:

type Fs interface {
...
// Put in to the remote path with the modTime given of the given size
//
// When called from outside an Fs by rclone, src.Size() will always be >= 0.
// But for unknown-sized objects (indicated by src.Size() == -1), Put should either
// return an error or upload it properly (rather than e.g. calling panic).
//
// May create the object even if it returns an error - if so
// will return the object and the error, otherwise will return
// nil and the error
Put(ctx context.Context, in io.Reader, src ObjectInfo, options ...OpenOption) (Object, error)

Rclone already implements the Fs interface for each supported provider, the full list can be found here

Create the Put method for the base struct RcloneDisk

func (r *RcloneDisk) Put(ctx context.Context, reader io.Reader, size int64, mime, dst string) (*FileInfo, error) {
	objectInfo := object.NewStaticObjectInfo(
		dst,
		time.Now(),
		size,
		true,
		nil,
		nil,
	)

	rs, err := r.Fs.Put(ctx, reader, objectInfo)

	if err != nil {
		return nil, err
	}

	return &FileInfo{
		Disk: r.DiskName,
		Path: dst,
		Type: mime,
		Size: int(rs.Size()),
	}, nil
}

As defined in the Rclone Fs interface, the Put method receives these parameters:

• ctx: A context for easily controlling the method behavior
• reader: An io.Reader object that holds the file upload reader, we will get this reader from the *multipart.FileHeader
• src: A rclonefs.ObjectInfo object that holds the file information. In order to create this object will have to collect some additional information as file size, upload destination

Create the Multipart method for the base struct RcloneDisk

func (r *RcloneDisk) Multipart(ctx context.Context, m *multipart.FileHeader, dsts ...string) (*FileInfo, error) {
	f, err := m.Open()

	if err != nil {
		return nil, err
	}

	fileHeader := make([]byte, 512)

	if _, err := f.Read(fileHeader); err != nil {
		return nil, err
	}

	if _, err := f.Seek(0, 0); err != nil {
		return nil, err
	}

	dst := ""
	mime := http.DetectContentType(fileHeader)

	if len(dsts) > 0 {
		dst = dsts[0]
	} else {
		dst = r.UploadFilePath(m.Filename)
	}

	return r.Put(ctx, f, m.Size, mime, dst)
}

Create the default file path for every upload

func (r *RcloneDisk) UploadFilePath(filename string) string {
    var filenameRemoveCharsRegexp = regexp.MustCompile(`[^a-zA-Z0-9_\-\.]`)
    var dashRegexp = regexp.MustCompile(`\-+`)
	now := time.Now()
	filename = filenameRemoveCharsRegexp.ReplaceAllString(filename, "-")
	filename = dashRegexp.ReplaceAllString(filename, "-")
	filename = strings.ReplaceAll(filename, "-.", ".")
	return path.Join(
		r.Root,
		strconv.Itoa(now.Year()),
		fmt.Sprintf("%02d", int(now.Month())),
		fmt.Sprintf("%d_%s", now.UnixMicro(), filename),
	)
}

func (r *RcloneDisk) Delete(ctx context.Context, filepath string) error {
	obj, err := r.Fs.NewObject(ctx, filepath)

	if err != nil {
		return err
	}

	return obj.Remove(ctx)
}

Note:

Because will Read the file to check its mime f.Read(fileHeader), we have to seek it at the start of the io.Reader to avoid file corruption: f.Seek(0, 0)

The basic implementation of the RcloneDisk is done, we will create the S3 Disk and the Local Disk that extend this base disk in the steps bellow.

Create the local disk: Save file to the local storage

type RcloneLocal struct {
	*RcloneDisk
	Root      string        `json:"root"`
	BaseUrl   string        `json:"base_url"`
}

func (r *RcloneLocal) Url(filepath string) string {
	return r.BaseUrl + "/" + filepath
}

This struct contains extra properties:

• Root: The root directory for the upload
• Baseurl: The base url for the public file url

Create the local disk:

import (
	"context"
	"os"

	"github.com/rclone/rclone/backend/local"
	"github.com/rclone/rclone/fs/config/configmap"
)

func NewLocal() Disk {
	rl := &RcloneLocal{
		BaseRcloneDisk: &BaseRcloneDisk{
			DiskName: "local_disk",
		},
		Root:      "/var/www/html/files",
		BaseUrl:   "/files",
	}

	cfgMap := configmap.New()
	cfgMap.Set("root", rl.Root)
	fsDriver, err := local.NewFs(context.Background(), rl.DiskName, rl.Root, cfgMap)

	if err != nil {
		panic(err)
	}

	rl.Fs = fsDriver

	return rl
}

In this code, we import the Local backend that implemented the Rclone Fs: "github.com/rclone/rclone/backend/local"

Create the S3 disk: Save file to AWS S3 or S3 compatible storage providers

type RcloneS3 struct {
	*RcloneDisk
	Root            string              `json:"root"`
	Provider        string              `json:"provider"`
	Bucket          string              `json:"bucket"`
	Region          string              `json:"region"`
	Endpoint        string              `json:"endpoint"`
	ChunkSize       fs.SizeSuffix       `json:"chunk_size"`
	AccessKeyID     string              `json:"access_key_id"`
	SecretAccessKey string              `json:"secret_access_key"`
	BaseUrl         string              `json:"base_url"`
	ACL             string              `json:"acl"`
}

func (r *RcloneS3) Url(filepath string) string {
	return r.BaseUrl + filepath
}

Create the S3 disk

import (
	"context"

	"github.com/rclone/rclone/backend/s3"
	"github.com/rclone/rclone/fs"
	"github.com/rclone/rclone/fs/config/configmap"
)


func NewS3(cfg *RcloneS3Config) fs.FSDisk {
	rs3 := &RcloneS3{
		BaseRcloneDisk: &BaseRcloneDisk{
			DiskName: "DO_DISK",
			Root:     "/files",
		},
		Root:            "/files",
		Provider:        "DigitalOcean",
		Region:          "sfo3",
		Endpoint:        "sfo3.digitaloceanspaces.com",
		ChunkSize:       rclonefs.SizeSuffix(1024 * 1024 * 5),
		AccessKeyID:     "AccessKeyID",
		SecretAccessKey: "SecretAccessKey",
		BaseUrl:         "https://cdn.mysite",
		ACL:             "public-read",
	}

	cfgMap := &configmap.Simple{}
	cfgMap.Set("provider", rs3.Provider)
	cfgMap.Set("bucket", rs3.Bucket)
	cfgMap.Set("region", rs3.Region)
	cfgMap.Set("endpoint", rs3.Endpoint)
	cfgMap.Set("chunk_size", rs3.ChunkSize.String())
	cfgMap.Set("access_key_id", rs3.AccessKeyID)
	cfgMap.Set("secret_access_key", rs3.SecretAccessKey)
	cfgMap.Set("acl", rs3.ACL)
	cfgMap.Set("bucket_acl", rs3.ACL)

	fsDriver, err := s3.NewFs(context.Background(), "s3", rs3.Bucket, cfgMap)

	if err != nil {
		panic(err)
	}

	rs3.Fs = fsDriver

	return rs3
}

In this code, we import the S3 backend that implemented the Rclone Fs: "github.com/rclone/rclone/backend/s3"

Usage

var localDisk = NewLocal()
var s3Disk = NewS3()

func Upload(c server.Context) error {
    ctx := context.Background()
    fileHeader := c.File("file") // *multipart.FileHeader
    localDisk.Multipart(ctx, fileHeader) // Save file to the local storage
    s3Disk.Multipart(ctx, fileHeader) // Save file to the S3 compatible storage
}

Conclusion

In this post, we just talked about the File Saving process using Rclone, there are many features that Rclone offers. By looking into the source code we can directly use Rclone APIs without using its binary.

Thank you for spending time on my post, if you have any questions, don’t hesitate to leave a comment here!

• Check if slice contain an element
• Filter out slice element that match some condition
• Map a slice to a diffrence type

It was a common case that i have to rewrite every helper for difference type of data, and it’s so annoy.

With the recent version 18 of Go, i decided to rewrite the common slice function with the help of Generic. As an expected result, generic work good and help me avoid the redundant/dry code.

Here are some slice helper functions that i want to share:

Contains: Check if a slice contain an element

func Contains[T comparable](slice []T, element T) bool {
	for _, e := range slice {
		if e == element {
			return true
		}
	}

	return false
}

Usage

var stringSlice = []string{"item 1", "item 2"}
var intSlice = []int{1, 2, 3}

fmt.Println(Contains(stringSlice, "item 2")) // true
fmt.Println(Contains(intSlice, 4)) // false

Filter: Filter a slice to return only the elements that match a condition

func Filter[T comparable](slice []T, predicate func(T) bool) []T {
	var result []T
	for _, e := range slice {
		if predicate(e) {
			result = append(result, e)
		}
	}

	return result
}

Usage

var intSlice = []int{1, 2, 3, 4, 5, 6, 7, 8, 9}

var oddSlice = Filter(intSlice, func(element int) bool {
    return element % 2 != 0
})

fmt.Println(oddSlice) // []int{1, 3, 5, 7, 9}

Map: Transform a slice into a diffrence slice type

func Map[T comparable, R comparable](slice []T, mapper func(T) R) []R {
	var result []R
	for _, e := range slice {
		result = append(result, mapper(e))
	}

	return result
}

Usage

var intSlice = []int{1, 2, 3}
var strSlice = Map(intSlice, func(element int) string {
    return strconv.Itoa(element)
})

fmt.Println(strSlice) // []string{"1", "2", "3"}

Repeat: Create a slice with a repeated values

func Repeat[T comparable](input T, time int) []T {
	var result []T
	var i = 0
	for i < time {
		result = append(result, input)
		i++
	}

	return result
}

Usage

var intSlice = Repeat(1, 3)

fmt.Println(intSlice) // []int{1, 1, 1}

Overlap: Get the overlap elements beetween two slice

func Overlap[T comparable](slice1 []T, slice2 []T) []T {
	result := make([]T, 0)
	for _, e1 := range slice1 {
		if SliceContains(slice2, e1) {
			result = append(result, e1)
		}
	}

	return result
}

Usage

var slice1 = []int{1, 2, 3}
var slice2 = []int{2, 3, 4}
var result = Overlap(slice1, slice2)

fmt.Println(result) // []int{2, 3}

AppendIfNotExists: Append an element to a slice only if it isn’t existed

func AppendIfNotExists[T comparable](slice []T, newItem T) []T {
	for _, s := range slice {
		if s == newItem {
			return slice
		}
	}

	return append(slice, newItem)
}

Usage

var intSlice = []int{1, 2, 3}
var intSlice1 = AppendIfNotExists(intSlice, 3)
var intSlice2 = AppendIfNotExists(intSlice, 4)

fmt.Println(intSlice1) // []int{1, 2, 3}
fmt.Println(intSlice2) // []int{1, 2, 3, 4}

Some time you may want to append an item to a slice only if a certain condition is matched or the Type is not comparable, you can modify the AppendIfNotExists as bellow:

func AppendIfNotExists[T any](slice []T, newItem T, checkExists func(T) bool) []T {
	for _, s := range slice {
		if checkExists(s) {
			return slice
		}
	}

	return append(slice, newItem)
}

Usage

type Thing struct {
    ID int
    Name string
}

var things = []Thing{
	{ID: 1, Name: "one"},
	{ID: 2, Name: "two"},
}

var thing3 = Thing{ID: 3, "three"}
var thing2 = Thing{ID: 2, Name: "Thing 2"}

var thingSlice1 = AppendIfNotExists(things, thing2, func (element Thing) bool {
    return element.ID == thing2.ID
})

var thingSlice2 = AppendIfNotExists(things, thing3, func (element Thing) bool {
    return element.ID == thing3.ID
})

fmt.Println(len(thingSlice1)) // 2
fmt.Println(len(thingSlice2)) // 3

There are things that will be guided in this section:

• Install Docker
• Deploy Portainer container
• Deploy Tetua container
• Deploy Nginx container

Install Docker

Follow these links for the detailed document on how to install Docker and docker-compose:

Deploy Portainer container

Create portainer docker-compose file:

mkdir -p /opt/containers/portainer/data
touch /opt/containers/docker-compose.yml

Update file /opt/containers/docker-compose.yml with the following content:

version: '3'

services:
  portainer:
    image: portainer/portainer:latest
    container_name: portainer
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    networks:
      - proxy
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./data:/data

networks:
  proxy:
    external: true

Run the portainer container

cd /opt/containers/portainer
docker-compose up -d

Deploy Tetua container

Download and extract the Tetua binary:

mkdir -p /opt/containers/tetua
cd /opt/containers/tetua
wget https://github.com/ngocphuongnb/tetua/releases/download/v0.0.3-alpha/tetua_0.0.3-alpha_Linux_x86_64.tar.gz
tar -xvf tetua_0.0.3-alpha_Linux_x86_64.tar.gz

Create /opt/containers/Dockerfile with this content;:

FROM ubuntu:bionic

ARG DEBIAN_FRONTEND=noninteractive
RUN apt-get update
RUN apt-get install -yq ca-certificates
RUN apt-get install tzdata -y

WORKDIR /tetua


COPY ./tetua /tetua/tetua

EXPOSE 3000

CMD ./tetua run

Create /opt/containers/docker-compose.yml with this content:

version: '3'

services:
  tetua:
    container_name: tetua
    image: tetua
    restart: always
    build:
      context: .
      dockerfile: ./Dockerfile
    environment:
      APP_ENV: production
    volumes:
      - ./config.json:/tetua/config.json
      - ./public:/tetua/public
      - ./private:/tetua/private
    networks:
      - proxy

networks:
  proxy:
    external: true

Create the Tetua config file:

./tetua init
./tetua setup -u admin -p password

Run the Tetua container

cd /opt/containers/tetua
docker-compose up -d

Deploy Nginx container

mkdir -p /opt/containers/nginx/conf.d

Create file /opt/containers/nginx/docker-compose.yml with this content

version: '3'

services:
  nginx:
    container_name: nginx
    image: nginx
    restart: always
    volumes:
      - ./conf.d/portainer.nginx.conf:/etc/nginx/conf.d/portainer.nginx.conf
      - ./conf.d/tetua.nginx.conf:/etc/nginx/conf.d/tetua.nginx.conf
    ports:
      - 80:80
    command: /bin/sh -c "exec nginx -g 'daemon off;'"
    networks:
      - proxy

networks:
  proxy:
    external: true

Create file /opt/containers/nginx/conf.d/portainer.nginx.conf with this content:

upstream app_portainer {
  server portainer:9000;
}

server {
  listen 80;
  server_name portainer.mytetuaapp.local;
  root /data;

  access_log /var/log/nginx/nginx.portainer.log;
  error_log /var/log/nginx/nginx.portainer.error.log;

  location / {
    index index.html index.htm;
    try_files $uri @portainer;
  }

  location @portainer {
    proxy_set_header Host $http_host;
    proxy_set_header X-Forwarded-For $remote_addr;
    proxy_pass http://app_portainer;
    add_header X-Cache-Status $upstream_cache_status;
  }
}

Create file /opt/containers/nginx/conf.d/tetua.nginx.conf with this content:

upstream app_tetua {
  server tetua:3000;
}

server {
  listen 80;
  server_name mytetuaapp.local;

  access_log /var/log/nginx/nginx.tetua.log;
  error_log /var/log/nginx/nginx.tetua.error.log;

  location / {
    index index.html index.htm;
    try_files $uri @tetua;
  }

  location @tetua {
    proxy_set_header Host $http_host;
    proxy_set_header X-Forwarded-For $remote_addr;
    proxy_pass http://app_tetua;
    add_header X-Cache-Status $upstream_cache_status;
  }
}

Run the Nginx container

cd /opt/containers/nginx
docker-compose up -d

You can now be able to access the Portainer dashboard to manage the server containers: https://portainer.mytetuaapp.local

And the Tetua app will be available at https://mytetuapp.local

Tetua provide binary packages for easy setting up and running a blog, these are supported plattform:

• Darwin_arm64
• Darwin_x86_64
• Linux_arm64
• Linux_i386
• Linux_x86_64
• Windows_arm64
• Windows_i386
• Windows_x86_64

To run a Tetua blog, you have to download and and execute the binary.
The current version is v0.0.5-alpha so if you want to deploy a blog, the process is as following:

Download and extract the binary

mkdir -p /home/myblog
wget https://github.com/ngocphuongnb/tetua/releases/download/v0.0.3-alpha/tetua_0.0.3-alpha_Linux_x86_64.tar.gz
tar -xvf tetua_0.0.5-alpha_Linux_x86_64.tar.gz

Create the config file

./tetua init

The config file will be created in the current directory:

{
 "app_env": "production",
 "app_key": "{APP_KEY}",
 "app_port": "3000",
 "db_dsn": "",
 "github_client_id": "",
 "github_client_secret": "",
 "db_query_logging": false
}

These fields are required:

• app_key: the key to encrypt the data
• db_dsn: the database connection string
• github_client_id: the client id for github
• github_client_secret: the client secret for github

You can skip this initialization step by specifying the environment variables:

• APP_KEY
• DB_DSN
• GITHUB_CLIENT_ID
• GITHUB_CLIENT_SECRET

The full config file is as bellow:

{
	"app_env": "production",
	"app_key": "{app_key}",
	"app_token_key": "token",
	"app_port": "3000",
	"app_theme": "default",
	"db_dsn": "root:123@tcp(127.0.0.1:3306)/myblog?charset=utf8mb4&collation=utf8mb4_unicode_ci&parseTime=true",
	"github_client_id": "{github_client_id}",
	"github_client_secret": "{github_client_secret}",
	"cookie_uuid": "uuid",
	"show_tetua_block": false,
	"db_query_logging": false,
	"storage": {
		"default_disk": "local_public",
		"disks": [
			{
				"name": "local_public",
				"driver": "local",
				"root": "./public",
				"base_url": "http://localhost:3000/storage/",
				"provider": "local",
			}, {
				"name": "do_public",
				"driver": "s3",
				"root": "./files",
				"base_url": "cdn.myapp.local/files",
				"provider": "DigitalOcean",
				"endpoint": "sfo3.digitaloceanspaces.com",
				"region": "sfo3",
				"bucket": "myblock",
				"access_key_id": "{access_key_id}",
				"secret_access_key": "{secret_access_key}",
				"acl": "public-read"
			}
		]
	}
}

All the environment variables that Tetua use are:

APP_ENV
APP_KEY
APP_TOKEN_KEY
APP_PORT
APP_THEME
DB_DSN
DB_QUERY_LOGGING
GITHUB_CLIENT_ID
GITHUB_CLIENT_SECRET
ROOT_DIR
PUBLIC_DIR
PRIVATE_DIR
COOKIE_UUID
SHOW_TETUA_BLOCK

Create the Admin account

./tetua setup -u admin -p password

Run the server

./tetua run

Result

 ┌───────────────────────────────────────────────────┐
 │                  Tetua Community                  │
 │                   Fiber v2.30.0                   │
 │               http://127.0.0.1:3000               │
 │       (bound on host 0.0.0.0 and port 3000)       │
 │                                                   │
 │ Handlers ........... 553  Processes ........... 1 │
 │ Prefork ....... Disabled  PID ............. 30014 │
 └───────────────────────────────────────────────────┘