JAX 2024: Go in der Praxis einsetzen

gh Github CLI
149.298 Zeilen Code
490 Contributors

1. 🖥️ CLI Tools
2. 🌐 Web App
3. λ Lambda Function

5 Fakten zu Go
1. statisches Typsystem
2. Garbage Collection
3. keine Vererbung
4. Concurrency eingebaut
5. native Ausführung
Linux, Win, z/OS, 386, amd64, ARM, wasm, ...

Go Proverbs
18 Prinzipien zurGo Entwicklung
#
von Rob Pike 2015 vorgestellt
#
"Clearis betterthan clever."
#

CLI Proverbs ohne Argumente
> pro
Clear is better than clever.

CLI Projekt aufsetzen
// 1. Go Modul erstellen (erzeugt go.mod)
> go mod init crossnative.com/pro
// 2. Datei main.go erstellen
package main
import "fmt"
func main() {
fmt.Println("Hello Go Pro!")
}
Ausführen
go build . // 1. Code kompilieren
./pro // 2. Binary ausführen
go run . // Code kompilieren und ausführen

Entwicklung
JetBrains
GoLand
Visual
Studio Code Vim Go

Proverbs Modul nutzen
// 1. Proverbs Modul Dependency
> go get github.com/jboursiquot/go-proverbs
// 2. Go Modul Descriptor go.mod
module crossnative.com/pro
go 1.22
require github.com/jboursiquot/go-proverbs v0.0.2

Zufälliges Proverb ausgeben
import (
"github.com/jboursiquot/go-proverbs"
)
package main
1
2
3
"fmt"
4
5
6
7
func main() {
8
fmt.Println(proverbs.Random())
9
}
10
import (
)
package main
1
2
3
"fmt"
4
5
6
7
func main() {
8
9
}
10
package main
import (
"fmt"
)
func main() {
}
1
2
3
4
5
6
7
8
9
10
// Ausgabe `go run .`
&{Make the zero value useful. http://youtube.com/322}

💡Structs und Pointer
// Pointer Variable auf Proverb Struct
var p *proverbs.Proverb = proverbs.Random()
package main
1
2
import (
3
"fmt"
4
5
)
6
7
func main() {
8
9
10
11
fmt.Println(p)
12
}
13
package main
import (
"fmt"
)
func main() {
// Pointer Variable auf Proverb Struct
fmt.Println(p)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
// Struct statt Klasse
type Proverb struct {
Saying string
Link string
}
1
2
3
4
5

Zufälliges Proverb ausgeben
import (
)
package main
1
2
3
"fmt"
4
5
6
7
func main() {
8
9
10
// Zugriff auf Property des Structs
11
fmt.Println(p.Saying)
12
}
13
import (
)
package main
1
2
3
"fmt"
4
5
6
7
func main() {
8
9
10
11
12
}
13
package main
1
2
import (
3
"fmt"
4
5
)
6
7
func main() {
8
9
10
11
12
}
13
package main
import (
"fmt"
)
func main() {
}
1
2
3
4
5
6
7
8
9
10
11
12
13
// Ausgabe `go run .`
Make the zero value useful.

CLI Proverbs mit Count
> pro -count=3
Clear is better than clever.
Documentation is for users.
Don't panic.

Flag fürCount
"flag"
// 1. Flags definieren
var count *int = flag.Int("count", 1, "proverb count")
import (
1
2
"fmt"
3
4
)
5
6
func main() {
7
8
9
10
// 2. Flags parsen
11
flag.Parse()
12
13
// 3. Ausgabe in Schleife
14
for i := 0; i < *count; i++ {
15
16
17
}
18
}
19
// 2. Flags parsen
flag.Parse()
import (
1
"flag"
2
"fmt"
3
4
)
5
6
func main() {
7
8
9
10
11
12
13
14
for i := 0; i < *count; i++ {
15
16
17
}
18
}
19
for i := 0; i < *count; i++ {
}
import (
1
"flag"
2
"fmt"
3
4
)
5
6
func main() {
7
8
9
10
// 2. Flags parsen
11
flag.Parse()
12
13
14
15
16
17
18
}
19
import (
"flag"
"fmt"
)
func main() {
// 2. Flags parsen
flag.Parse()
for i := 0; i < *count; i++ {
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Compile mit `go build .`, Ausgabe mit `pro -count=2`
Reflection is never clear.

CLI Proverbs mit ungültigem Count
> pro -count=
flag needs an argument: -count
Usage of ./pro:
-count int
proverb count (default 1)

Flag fürCount Refactored
count := flag.Int("count", 1, "proverb count")
p := proverbs.Random()
import (
1
"flag"
2
"fmt"
3
4
)
5
6
func main() {
7
8
9
10
// 2. Flags parsen
11
flag.Parse()
12
13
14
for range *count {
15
16
17
}
18
}
19
for range *count {
}
import (
1
"flag"
2
"fmt"
3
4
)
5
6
func main() {
7
8
9
10
// 2. Flags parsen
11
flag.Parse()
12
13
14
15
16
17
18
}
19
import (
"flag"
"fmt"
)
func main() {
// 2. Flags parsen
flag.Parse()
for range *count {
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Compile mit `go build .`, Ausgabe mit `pro -count=2`
Reflection is never clear.

🖥️CLI Tool
File Downloader

File Downloader
ParallelerFile Download
#
Nutzt Goroutinen und Channels
#
Context is King
#

File Downloader1/3
func main() {
urls := []string{
"https://go.dev/dl/go1.22.2.src.tar.gz",
"https://go.dev/dl/go1.22.2.darwin-amd64.tar.gz",
}
}
1
2
3
4
5
6
// URL Download
7
ctx := context.Background()
8
downloadURLs(ctx, urls)
9
10
11
func downloadURLs(ctx context.Context, urls []string) {
12
// ...
13
}
14
func main() {
urls := []string{
}
}
1
2
3
4
5
6
// URL Download
7
8
9
10
11
12
// ...
13
}
14
func main() {
// URL Download
}
1
urls := []string{
2
3
4
}
5
6
7
8
9
10
11
12
// ...
13
}
14
func main() {
urls := []string{
}
// URL Download
}
// ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

File Downloader2/3
// 1. Channel für Download Jobs
jobs := make(chan int, len(urls))
1
2
3
4
// 2. Go Routinen für Downloads starten
5
for _, url := range urls {
6
go func() {
7
downloadURL(ctx, url)
8
jobs <- 1 // Send an Channel (blockiert)
9
}()
10
}
11
12
// 3. Warten auf Ende aller Go Routinen
13
for range len(urls) {
14
<-jobs // Receive von Channel (blockiert)
15
}
16
}
17
go func() {
}()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
}
16
}
17
}
1
2
3
4
5
6
go func() {
7
8
9
}()
10
}
11
12
13
14
15
16
}
17
go func() {
}()
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

File Downloader3/3
func downloadURL(ctx context.Context, url string) {
// 1. HTTP Request mit Context erstellen
req, _ := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
1
2
3
4
// 2. HTTP Aufruf durchführen
5
httpClient := http.Client{}
6
resp, _ := httpClient.Do(req)
7
defer resp.Body.Close()
8
9
// 3. Ausgabe in Datei
10
file, _ := os.Create(filepath.Base(url))
11
defer file.Close()
12
13
// 4. HTTP Body in Datei streamen
14
io.Copy(file, resp.Body)
15
}
16
1
2
3
4
5
6
7
8
9
10
11
defer file.Close()
12
13
14
15
}
16
defer file.Close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
}
16
1
2
3
4
5
6
7
8
9
10
11
defer file.Close()
12
13
14
15
}
16
defer file.Close()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

File Downloader3/3 mit Fehlern
func downloadURL(ctx context.Context, url string) error {
}
1
2
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
3
if err != nil {
4
return err
5
}
6
7
8
// ...
9
10
if err != nil {
return err
}
1
2
3
4
5
6
7
8
// ...
9
}
10
if err != nil {
return err
}
// ...
}
1
2
3
4
5
6
7
8
9
10

File Downloadermit Timeout
// 1. Context mit Cancel Func
ctx, cancel := context.WithCancel(context.Background())
// 3. URL Download
func main() {
1
urls := []string{
2
3
4
}
5
6
7
8
9
// 2. Timer Channel nutzen
10
timer := time.After(3 * time.Second)
11
go func() {
12
<-timer // Receive timer Channel
13
log.Println("Canceled due to timeout")
14
cancel()
15
}()
16
17
18
19
}
20
go func() {
cancel()
}()
func main() {
1
urls := []string{
2
3
4
}
5
6
7
8
9
10
11
12
13
14
15
16
17
// 3. URL Download
18
19
}
20
go func() {
cancel()
}()
// 3. URL Download
func main() {
1
urls := []string{
2
3
4
}
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
}
20

File Downloadermit Interrupt
// 3. URL Download
func main() {
1
urls := []string{
2
3
4
}
5
6
7
8
9
// 2. Interrupt Channel nutzen
10
interrupt := make(chan os.Signal, 1)
11
signal.Notify(interrupt, os.Interrupt, syscall.SIGTERM)
12
go func() {
13
<-interrupt // Receive interrupt Channel
14
log.Println("Canceled due to interrupt")
15
cancel()
16
}()
17
18
19
20
}
21
go func() {
cancel()
}()
func main() {
1
urls := []string{
2
3
4
}
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 3. URL Download
19
20
}
21
go func() {
cancel()
}()
// 3. URL Download
func main() {
1
urls := []string{
2
3
4
}
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
}
21

File Downloadermit Select
// + Timeout Channel
// + Interrupt Channel
func main() {
1
2
3
4
5
go func() {
6
select {
7
// 2a. Receive timer Channel
8
case <-timer:
9
10
cancel()
11
// 2b. Receive interrupt Channel
12
case <-interrupt:
13
14
cancel()
15
}
16
}()
17
18
// 3. URL Download
19
20
}
21
select {
case <-timer:
cancel()
}
func main() {
1
2
3
4
5
go func() {
6
7
8
9
10
11
12
case <-interrupt:
13
14
cancel()
15
16
}()
17
18
// 3. URL Download
19
20
}
21
select {
case <-interrupt:
cancel()
}
func main() {
1
2
3
4
5
go func() {
6
7
8
case <-timer:
9
10
cancel()
11
12
13
14
15
16
}()
17
18
// 3. URL Download
19
20
}
21
select {
case <-timer:
cancel()
case <-interrupt:
cancel()
}
func main() {
1
2
3
4
5
go func() {
6
7
8
9
10
11
12
13
14
15
16
}()
17
18
// 3. URL Download
19
20
}
21

🖥️CLI Tools
Standardlib Flags
#
einfache Releases mit Goreleaser
#
Cobra CLI Lib wenn's komplexerwird
#
Github, Kubernetes sind Go CLIs
#

Set up Cats App
# 1. Verzeichnis erstellen
mkdir cats
cd cats
# 2. Go Modul aufsetzen
go mod init crossnative.com/cats
# 3. Go Datei erstellen
touch main.go

Cat API simple
func main() {
http.HandleFunc("GET /api/cats", catAPIHandler)
http.ListenAndServe(":8080", nil)
}
func catAPIHandler(w http.ResponseWriter, r *http.Request) {
1
fmt.Fprintf(w, "Meow!")
2
w.WriteHeader(http.StatusOK)
3
}
4
5
6
7
8
9
fmt.Fprintf(w, "Meow!")
w.WriteHeader(http.StatusOK)
}
1
2
3
4
5
func main() {
6
7
8
}
9

Cat API mit JSON
// 1. Struct mit JSON Tag definieren
type Cat struct {
Name string `json:"name"`
}
1
2
3
4
5
6
// 2. Slice erstellen
7
cats := make([]Cat, 1)
8
9
// 3. Struct erstellen und einfügen
10
cats[0] = Cat{Name: "Ginger"}
11
12
// 4. JSON rendern
13
json.NewEncoder(w).Encode(cats)
14
}
15
16
func main() {
17
18
19
}
20
}
1
type Cat struct {
2
3
}
4
5
6
7
8
9
10
11
12
// 4. JSON rendern
13
14
15
16
func main() {
17
18
19
}
20
}
1
type Cat struct {
2
3
}
4
5
6
7
8
9
10
11
12
// 4. JSON rendern
13
14
15
16
func main() {
17
18
19
}
20
}
1
type Cat struct {
2
3
}
4
5
6
7
8
9
10
11
12
// 4. JSON rendern
13
14
15
16
func main() {
17
18
19
}
20
// 4. JSON rendern
}
1
type Cat struct {
2
3
}
4
5
6
7
8
9
10
11
12
13
14
15
16
func main() {
17
18
19
}
20
type Cat struct {
}
// 4. JSON rendern
}
func main() {
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Cat API mit JSON
# Query cat API
curl -s http://localhost:8080/api/cats | jq
1
2
[
3
{
4
"name": "Ginger"
5
}
6
]
7
[
{
"name": "Ginger"
}
]
# Query cat API
1
curl -s http://localhost:8080/api/cats | jq
2
3
4
5
6
7

Test Cat API cat_api_test.go
func TestCatAPIHandler(t *testing.T) {
}
1
// 1. Test Request erstellen
2
req, _ := http.NewRequest("GET", "/api/cats", nil)
3
4
// 2. HTTP Recorder erstellen (ist http.ResponseWriter)
5
rec := httptest.NewRecorder()
6
7
// 3. Handler aufrufen
8
catAPIHandler(rec, req)
9
10
// 4. Response prüfen
11
if rec.Code != http.StatusOK {
12
t.Errorf("got status %v expected %v", rec.Code, http.StatusOK)
13
}
14
15
1
2
3
4
5
6
7
8
9
10
11
12
13
}
14
}
15
1
2
3
4
5
6
7
8
9
10
11
12
13
}
14
}
15
1
2
3
4
5
6
7
8
9
10
11
12
13
}
14
}
15
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
}
15
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Test ausführen
go test -v ./...
1
=== RUN TestCatAPIHandler
2
--- PASS: TestCatAPIHandler (0.00s)
3
PASS
4
coverage: 50.0% of statements
5
ok crossnative.com/cats 0.127s coverage: 50.0% of statements
6
=== RUN TestCatAPIHandler
--- PASS: TestCatAPIHandler (0.00s)
PASS
coverage: 50.0% of statements
ok crossnative.com/cats 0.127s coverage: 50.0% of statements
go test -v ./...
1
2
3
4
5
6

Cats Web App
// 1. Mulitplexer erzeugen
mux := http.NewServeMux()
func indexHandler(w http.ResponseWriter, r *http.Request) {
1
tpl := template.Must(template.ParseFiles("index.html"))
2
tpl.Execute(w, nil)
3
}
4
5
func main() {
6
7
8
9
// 2. Handler registrieren
10
mux.HandleFunc("/", indexHandler)
11
12
// 3. Server mit Mulitplexer starten
13
http.ListenAndServe(":8080", mux)
14
}
15
1
2
tpl.Execute(w, nil)
3
}
4
5
func main() {
6
7
8
9
10
11
12
13
14
}
15
1
2
tpl.Execute(w, nil)
3
}
4
5
func main() {
6
7
8
9
10
11
12
13
14
}
15
tpl.Execute(w, nil)
}
func main() {
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

File Serveraus Binary
//go:embed assets
var assets embed.FS
// Serve Files
mux.Handle("/assets/", http.FileServer(http.FS(assets)))
1
2
3
func main() {
4
5
6
7
8
9
10
11
}
12

Index HandlerTemplate mit Daten
type Cat struct {
Name string
}
func indexHandler(w ResponseWriter, r *Request) {
cat := make([]Cat, 1)
cat[0] = Cat{Name: "Ginger"}
// 3. Template rendern
tpl.Execute(w, cat)
}
<body>
<h1>Cats App</h1>
{{ range . }}
<h2>{{ .Name }}</h2>
{{ end }}
</body>

Index Handlermit Cats API
Query Cats API
GET https://api.thecatapi.com/v1/breeds?limit=5
[
{
"id": "abys",
"name": "Abyssinian",
"image": {
"url": "https://cdn2.thecatapi.com/0XYvRd7oD.jpg"
}
},
{
"id": "aege",
"name": "Aegean",
"image": {
"url": "https://cdn2.thecatapi.com/ozEvzdVM-.jpg"
}
},
...
]
Map JSON auf Struct
type Cat struct {
ID string `json:"id"`
Image struct {
URL string `json:"url"`
} `json:"image"`
}

Index Handlermit Cats API
// 1. Cat API Aufruf (Fehler ignorieren)
resp, _ := http.Get("https://api.thecatapi.com/v1/breeds?limit=5")
1
2
3
4
// 2. Slice für Cat Structs
5
6
7
// 3. Response Body parsen
8
9
body, _ := ioutil.ReadAll(resp.Body)
10
json.Unmarshal(body, &cat)
11
12
13
tpl.Execute(w, cat)
14
}
15
1
2
3
4
5
6
7
8
9
10
11
12
13
tpl.Execute(w, cat)
14
}
15
1
2
3
4
5
6
7
8
9
10
11
12
13
tpl.Execute(w, cat)
14
}
15
tpl.Execute(w, cat)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
}
15
tpl.Execute(w, cat)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Index Handlermit Fehlerhandling 💣
// 1. Cat API Aufruf
resp, err := http.Get("https://api.thecatapi.com/v1/breeds?limit=5")
1
2
3
// Fehler behandeln
4
if err != nil {
5
http.Error(w, "Cats API error", http.StatusInternalServerError)
6
return
7
}
8
9
10
11
12
13
14
15
err := json.Unmarshal(body, &cat)
16
// TODO: Fehler behandeln
17
18
19
err := tpl.Execute(w, cat)
20
21
}
22
// Fehler behandeln
if err != nil {
return
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
}
22
// Fehler behandeln
if err != nil {
return
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
}
22

🌐Web App
Standardlib JSON und Router
#
HTTPTests
#
Querschnittsfeatures durch Middleware
#

λ Lambda Function
Go ideal fürServerless Functions
#
schnellerStart, geringerSpeicherbedarf
#
unterstützt von AWS, Azure, Google
#

λ Lambda Function
// 1. Lambda Go Projekt aufsetzen
> sam init
1
2
3
// 2. Lambda bauen
4
> sam build
5
6
// 3. Lambda ausführen
7
> sam local invoke -e events/event.json
8
Invoking bootstrap (provided.al2023)
9
Local image is up-to-date
10
Using local image: public.ecr.aws/lambda/provided:al2023-rapid-x86_64.
11
12
Mounting .aws-sam/build/HelloWorldFunction, inside runtime container
13
REPORT RequestId: 37876f36 Init Duration: 0.52 ms Duration: 80.04 ms
14
Billed Duration: 81 ms Memory Size: 128 MB Max Memory Used: 128 MB
15
{"statusCode": 200, "body": "Hello JAX!"}
16
// 2. Lambda bauen
> sam build
1
> sam init
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1
> sam init
2
3
// 2. Lambda bauen
4
> sam build
5
6
7
8
9
10
11
12
13
14
15
16
> sam init
// 2. Lambda bauen
> sam build
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

λ Lambda Function
# Query AWS Lambda
curl -s https://0up9.eu-north-1.amazonaws.com/Prod/hello
1
2
Hello JAX!
3 Hello JAX!
# Query AWS Lambda
1
curl -s https://0up9.eu-north-1.amazonaws.com/Prod/hello
2
3
Footprint
Package Size 5,3 MB
Billed Duration 70 ms
Max Memory Used 18 MB
Init Duration 63.66 ms
#
#
#
#

λ Lambda Function
func main() {
lambda.Start(handler)
}
import (
1
"fmt"
2
"github.com/aws/aws-lambda-go/events"
3
"github.com/aws/aws-lambda-go/lambda"
4
)
5
6
func handler(req events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error)
7
return events.APIGatewayProxyResponse{
8
Body: "Hello JAX!",
9
StatusCode: 200,
10
}, nil
11
}
12
13
14
15
16
Body: "Hello JAX!",
StatusCode: 200,
}, nil
}
import (
1
"fmt"
2
3
4
)
5
6
7
8
9
10
11
12
13
func main() {
14
15
}
16
import (
"fmt"
)
Body: "Hello JAX!",
StatusCode: 200,
}, nil
}
func main() {
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

🖥️CLI Tools
Projekt Setup
Variablen,
Schleifen
Goroutinen,
Channels
Context
Structs
#
#
#
#
#
🌐Web App
Web Server
Slice
Unit Test
JSON
Fehlerhandling
#
#
#
#
#
λ Lambda Func
AWS Setup
Serverless
Experience
#
#

3 Gründe fürGo
1. Einfach
2. Mächtig
3. Langweilig

Go liebt
Microservices Serverless Functions
Kommandozeilen-Tools DevOps und Cloud

Jan Stamer
jan.stamer@crossnative.com

JAX 2024: Go in der Praxis einsetzen

Weitere ähnliche Inhalte

Mehr von Jan Stamer

JAX 2024: Go in der Praxis einsetzen