Упрощение разработки облачной инфраструктуры с Golang

// Пример простого HTTP-сервера на Go
package main
 
import (
    "net/http"
    "log"
)
 
func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello, Cloud!"))
    })
    log.Fatal(http.ListenAndServe(":8080", nil))
}

// Скомпилировать и запустить так же просто, как:
go build -o myapp .
./myapp

// Запуск миллиона горутин? Легко!
for i := 0; i < 1000000; i++ {
    go func(id int) {
        // Делаем что-то полезное
        fmt.Printf("Горутина %d выполняет работу\n", id)
    }(i)
}

// Элегантное взаимодействие через каналы
func worker(jobs <-chan int, results chan<- int) {
    for j := range jobs {
        results <- j * 2 // Удваиваем значение и отправляем обратно
    }
}
 
func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)
    
    // Запускаем 3 воркера
    for w := 1; w <= 3; w++ {
        go worker(jobs, results)
    }
    
    // Отправляем задачи
    for i := 1; i <= 9; i++ {
        jobs <- i
    }
    close(jobs)
    
    // Собираем результаты
    for i := 1; i <= 9; i++ {
        <-results
    }
}

// test.go
package main
 
import "testing"
 
func TestAddition(t *testing.T) {
    if 2+2 != 4 {
        t.Errorf("2+2 = %d, ожидалось 4", 2+2)
    }
}
 
// Запуск: go test
// Профилирование: go test -cpuprofile cpu.prof

# Многоэтапная сборка для минимального образа
FROM golang:1.18-alpine AS builder
WORKDIR /app
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o main .
 
FROM scratch
COPY --from=builder /app/main /main
ENTRYPOINT ["/main"]

package main
 
import (
    "net/http"
    "log"
)
 
func handler(w http.ResponseWriter, r *http.Request) {
    // Получаем данные из запроса
    user := r.URL.Query().Get("user")
    if user == "" {
        user = "Гость"
    }
    
    // Отвечаем
    w.Header().Set("Content-Type", "text/plain; charset=utf-8")
    w.Write([]byte("Привет, " + user + "!"))
}
 
func main() {
    // Регистрируем обработчик
    http.HandleFunc("/greet", handler)
    
    // Запускаем сервер на порту 8080
    log.Println("Сервер запущен на http://localhost:8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

// Пример компактной структуры данных
type User struct {
    ID        uint32   // 4 байта
    Name      string   // 16 байт (указатель + длина)
    Age       uint8    // 1 байт
    IsActive  bool     // 1 байт
}
// Вся структура занимает около 24 байт (с учётом выравнивания)
// Аналогичный класс в Java займёт минимум 40-50 байт из-за overhead

// Пример использования рефлексии для динамической маршрутизации запросов
func callMethod(obj interface{}, methodName string, args ...interface{}) []reflect.Value {
    method := reflect.ValueOf(obj).MethodByName(methodName)
    methodArgs := make([]reflect.Value, len(args))
    for i, arg := range args {
        methodArgs[i] = reflect.ValueOf(arg)
    }
    return method.Call(methodArgs)
}

func handleRequest(w http.ResponseWriter, r *http.Request) {
    // Создаём контекст с таймаутом 2 секунды
    ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
    defer cancel() // Убеждаемся, что ресурсы всегда освобождаются
    
    // Запрашиваем данные из другого сервиса
    result, err := fetchDataWithContext(ctx, "https://api.example.com/data")
    if err != nil {
        // Обрабатываем ошибку, включая таймаут
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    
    // Возвращаем результат
    w.Header().Set("Content-Type", "application/json")
    w.Write(result)
}

// Определяем структуру данных
type Product struct {
    ID          int     [INLINE]json:"id"[/INLINE]
    Name        string  [INLINE]json:"name"[/INLINE]
    Price       float64 `json:"price"`
    Description string  `json:"description,omitempty"`
    Tags        []string `json:"tags,omitempty"`
}
 
// Сериализуем в JSON
product := Product{
    ID:    1234,
    Name:  "Смартфон ГоФон",
    Price: 29999.99,
    Tags:  []string{"электроника", "гаджеты"},
}
jsonData, err := json.Marshal(product)
if err != nil {
    log.Fatal(err)
}
 
// Десериализуем из JSON
var newProduct Product
err = json.Unmarshal(jsonData, &newProduct)
if err != nil {
    log.Fatal(err)
}

// Минималистичная serverless-функция на Go для AWS Lambda
package main
 
import (
    "context"
    "github.com/aws/aws-lambda-go/lambda"
)
 
type Request struct {
    Name string `json:"name"`
}
 
type Response struct {
    Message string `json:"message"`
}
 
func HandleRequest(ctx context.Context, req Request) (Response, error) {
    return Response{
        Message: "Привет, " + req.Name + "!",
    }, nil
}
 
func main() {
    lambda.Start(HandleRequest)
}

// Edge-функция на Go, собираемая в WebAssembly
package main
 
import (
    "fmt"
    "syscall/js"
)
 
func processRequest(this js.Value, args []js.Value) interface{} {
    request := args[0]
    url := request.Get("url").String()
    
    // Обработка запроса прямо на edge-сервере
    response := fmt.Sprintf("Обработан запрос к %s на edge", url)
    
    return js.ValueOf(response)
}
 
func main() {
    c := make(chan struct{})
    js.Global().Set("processRequest", js.FuncOf(processRequest))
    <-c // Держим программу запущенной
}

var (
    // Инициализируется только раз при холодном старте
    dbClient *dynamodb.Client
    // Блокировка для безопасной инициализации
    initLock sync.Once
)
 
func initDependencies() {
    // Код выполняется только один раз
    cfg, err := config.LoadDefaultConfig(context.Background())
    if err != nil {
        log.Fatalf("Ошибка конфигурации: %v", err)
    }
    dbClient = dynamodb.NewFromConfig(cfg)
}
 
func HandleRequest(ctx context.Context, event APIGatewayEvent) (Response, error) {
    // Гарантируем, что зависимости инициализированы
    initLock.Do(initDependencies)
    
    // Основная логика функции
    // ...
}