Scribd
Upload
13 views

Go Programming Language Tutorial (Part 5)

A Go Programming Language Tutorial (Part 5)

Uploaded by

eowug
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
13 views

Go Programming Language Tutorial (Part 5)

A Go Programming Language Tutorial (Part 5)

Uploaded by

eowug
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 8

Go Programming Language Tutorial (Part 5)

This tutorial focuses on building and deploying microservices in Go, integrating middleware,
interacting with cloud services, and ensuring security in Go applications.

1. Building a Microservice
Microservice Basics
A microservice is a standalone, independently deployable service that focuses on a specific
functionality.

Example: User Service


go
Copy code
package main

import (
"encoding/json"
"net/http"
"github.com/gorilla/mux"
)

type User struct {


ID int `json:"id"`
Name string `json:"name"`
}

var users = []User{


{ID: 1, Name: "Alice"},
{ID: 2, Name: "Bob"},
}

// Get all users


func getUsers(w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode(users)
}

// Add a user
func addUser(w http.ResponseWriter, r *http.Request) {
var user User
json.NewDecoder(r.Body).Decode(&user)
users = append(users, user)
json.NewEncoder(w).Encode(user)
}

func main() {
r := mux.NewRouter()
r.HandleFunc("/users", getUsers).Methods("GET")
r.HandleFunc("/users", addUser).Methods("POST")

http.ListenAndServe(":8080", r)
}

Run the service and test it with tools like curl or Postman.

2. Middleware in Go
Middleware is a function that wraps HTTP handlers to perform tasks like logging, authentication, or
rate limiting.

Example: Logging Middleware


go
Copy code
package main

import (
"log"
"net/http"
"time"
)

func loggingMiddleware(next http.Handler) http.Handler {


return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
log.Printf("Started %s %s", r.Method, r.URL.Path)
next.ServeHTTP(w, r)
log.Printf("Completed in %s", time.Since(start))
})
}

func main() {
http.Handle("/", loggingMiddleware(http.HandlerFunc(func(w http.ResponseWriter,
r *http.Request) {
w.Write([]byte("Hello, Middleware!"))
})))

http.ListenAndServe(":8080", nil)
}

3. Service-to-Service Communication
RESTful Communication
Use Go’s net/http package to call other services.

Example: Calling Another Service


go
Copy code
package main
import (
"encoding/json"
"fmt"
"net/http"
)

type User struct {


ID int `json:"id"`
Name string `json:"name"`
}

func fetchUsers() ([]User, error) {


resp, err := http.Get("http://localhost:8080/users")
if err != nil {
return nil, err
}
defer resp.Body.Close()

var users []User


json.NewDecoder(resp.Body).Decode(&users)
return users, nil
}

func main() {
users, err := fetchUsers()
if err != nil {
fmt.Println("Error fetching users:", err)
return
}

for _, user := range users {


fmt.Printf("User: %s\n", user.Name)
}
}

4. Cloud Integration
AWS SDK Integration
Install the AWS SDK for Go:
bash
Copy code
go get github.com/aws/aws-sdk-go

Example: Upload to S3
go
Copy code
package main

import (
"bytes"
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/s3"
)

func uploadToS3() error {


sess := session.Must(session.NewSession(&aws.Config{
Region: aws.String("us-east-1"),
}))

svc := s3.New(sess)
bucket := "your-bucket-name"
key := "example.txt"
body := bytes.NewReader([]byte("Hello, S3!"))

_, err := svc.PutObject(&s3.PutObjectInput{
Bucket: aws.String(bucket),
Key: aws.String(key),
Body: body,
})
return err
}

func main() {
if err := uploadToS3(); err != nil {
fmt.Println("Failed to upload:", err)
} else {
fmt.Println("Upload successful!")
}
}

5. Secure Development Practices


Environment Variables
Use os or external libraries like github.com/joho/godotenv for managing sensitive
information.

Example: Using Environment Variables


go
Copy code
package main

import (
"fmt"
"os"
)

func main() {
apiKey := os.Getenv("API_KEY")
if apiKey == "" {
fmt.Println("API_KEY is not set")
} else {
fmt.Println("API_KEY:", apiKey)
}
}

Input Validation
Always validate user inputs to prevent injection attacks.

Example: Input Validation


go
Copy code
package main

import (
"net/http"
"regexp"
)

func validateInput(input string) bool {


valid, _ := regexp.MatchString("^[a-zA-Z0-9]+$", input)
return valid
}

func handler(w http.ResponseWriter, r *http.Request) {


name := r.URL.Query().Get("name")
if !validateInput(name) {
http.Error(w, "Invalid input", http.StatusBadRequest)
return
}
w.Write([]byte("Hello, " + name))
}

func main() {
http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)
}

6. API Gateway and Service Discovery


Use API Gateways like Kong or Traefik for routing traffic and handling service discovery.

Using Consul for Service Discovery


Install the Consul client:
bash
Copy code
go get github.com/hashicorp/consul/api

Example: Register a Service


go
Copy code
package main
import (
"log"
"github.com/hashicorp/consul/api"
)

func main() {
config := api.DefaultConfig()
client, err := api.NewClient(config)
if err != nil {
log.Fatal(err)
}

registration := &api.AgentServiceRegistration{
ID: "user-service",
Name: "user-service",
Address: "localhost",
Port: 8080,
}

if err := client.Agent().ServiceRegister(registration); err != nil {


log.Fatal(err)
}
log.Println("Service registered with Consul")
}

7. Observability
Distributed Tracing with Jaeger
Install Jaeger’s client library:
bash
Copy code
go get github.com/uber/jaeger-client-go

Example: Tracing with Jaeger


go
Copy code
package main

import (
"github.com/opentracing/opentracing-go"
"github.com/uber/jaeger-client-go"
"github.com/uber/jaeger-client-go/config"
"log"
)

func main() {
cfg := config.Configuration{
ServiceName: "my-service",
Sampler: &config.SamplerConfig{
Type: jaeger.SamplerTypeConst,
Param: 1,
},
Reporter: &config.ReporterConfig{
LogSpans: true,
LocalAgentHostPort: "localhost:6831",
},
}

tracer, closer, err := cfg.NewTracer()


if err != nil {
log.Fatal(err)
}
defer closer.Close()

opentracing.SetGlobalTracer(tracer)
span := tracer.StartSpan("my-operation")
span.Finish()
log.Println("Tracing example completed")
}

8. Deploying Go Microservices
Using Kubernetes
Deploy your microservice using Kubernetes.

Deployment YAML
yaml
Copy code
apiVersion: apps/v1
kind: Deployment
metadata:
name: user-service
spec:
replicas: 2
selector:
matchLabels:
app: user-service
template:
metadata:
labels:
app: user-service
spec:
containers:
- name: user-service
image: myuser-service-image:latest
ports:
- containerPort: 8080

Apply the configuration:


bash
Copy code
kubectl apply -f deployment.yaml
This tutorial equips you to build secure microservices, leverage cloud integrations, and deploy
applications using modern DevOps tools like Kubernetes. Continue exploring topics like serverless,
event-driven architectures, and multi-cloud strategies to deepen your expertise!

You might also like