Scribd
Upload
20 views

Go Programming Language Tutorial (Part 5)

A Go Programming Language Tutorial (Part 5)

Uploaded by

eowug
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
20 views

Go Programming Language Tutorial (Part 5)

A Go Programming Language Tutorial (Part 5)

Uploaded by

eowug
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
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