Михаил Р.

contents := []byte("Hello World")

// write a password zip
raw := new(bytes.Buffer)
zipw := zip.NewWriter(raw)
w, err := zipw.Encrypt("hello.txt", "golang")
if err != nil {
    log.Fatal(err)
}
_, err = io.Copy(w, bytes.NewReader(contents))
if err != nil {
    log.Fatal(err)
}
zipw.Close()

// read the password zip
zipr, err := zip.NewReader(bytes.NewReader(raw.Bytes()), int64(raw.Len()))
if err != nil {
    log.Fatal(err)
}
for _, z := range zipr.File {
    z.SetPassword("golang")
    rr, err := z.Open()
    if err != nil {
        log.Fatal(err)
    }
    _, err = io.Copy(os.Stdout, rr)
    if err != nil {
        log.Fatal(err)
    }
    rr.Close()
}

package pkg2
import "fmt"

type Pkg2 struct {
     str2 []string
}

func New() *Pkg2 {
    return &Pkg2{
        str2: []string{},
    }
}

func (p *Pkg2) Test(str string){
    p.str2 = append(p.str2, str)
    fmt.Printf("str:%v %v \n", str, p.str2)
}

package main

import (
  "sync"
  "pkg2"
)
var wg sync.WaitGroup

func main() {
  text:=[]string{"a1", "a2", "a3", "a4", "a5"}
  for i,str:=range text{
    wg.Add(1)
    p := pkg2.New()
    go start(str, p)
  }
  wg.Wait()
}

func start(str string, p *pkg2.Pkg2){
    p.Test(str)
    wg.Done()
}

package main

import (
	"log"

	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
)

func main() {
	bot, err := tgbotapi.NewBotAPI("MyAwesomeBotToken")
	if err != nil {
		log.Panic(err)
	}

	u := tgbotapi.NewUpdate(0)
	u.Timeout = 60

	updates := bot.GetUpdatesChan(u)

	for update := range updates {
            if update.Message == nil { // не обрабатываем если нет сообщения
                continue
            }

            // ID сообщения, int
            log.Printf("message id: %s\n", update.Message.MessageID)

            // так вы можете получить текст сообщения полный (тип string)
            log.Printf("message: %s\n", update.Message.Text)

            if update.Message.IsCommand() {
                // так вы получаете команду
                log.Printf("command: %s\n", update.Message.Command())

                // так вы получаете аргументы (параметры) команды, string
                log.Printf("command: %s\n", update.Message.CommandArguments())
            }
        }
    }
}

Но я считаю что на реакте будет лучше.

Скажите просто несколько доводов в сторону реакт.

func (db *Requests) StorePhotos(ctx context.Context, photos []Photo) error {
	ctx, cancel := context.WithTimeout(ctx, time.Minute*2)
	defer cancel()

	tx, err := db.BeginTx(ctx, nil)
	if err != nil {
		return err
	}
	defer tx.Rollback()

	stmnt, err := tx.PrepareContext(ctx, "INSERT INTO photos (id, owner_id, req_id, url) VALUES ($1, $2, $3, $4)")
	if err != nil {
		return err
	}
	defer stmnt.Close()

	for _, photo := range photos {
		if _, err = stmnt.ExecContext(ctx, photo.ID, photo.OwnerID, photo.ReqID, photo.URL); err != nil {
			return err
		}
	}

	return tx.Commit()
}

Server Software:
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        5 bytes

Concurrency Level:      1000
Time taken for tests:   0.509 seconds
Complete requests:      10000
Failed requests:        0
Write errors:           0
Total transferred:      1210000 bytes
HTML transferred:       50000 bytes
Requests per second:    19627.39 [#/sec] (mean)
Time per request:       50.949 [ms] (mean)
Time per request:       0.051 [ms] (mean, across all concurrent requests)
Transfer rate:          2319.25 [Kbytes/sec] received

input {
    appearance: none;
}