Go: HTTP-серверы, context и конкурентность

Шаблон для выполнения внешних HTTP-запросов в Go с использованием пакета context. Задание лимита времени на выполнение запроса предотвращает «зависание» горутин при сетевых сбоях или медленных ответах от удаленного API.

package main

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

func fetchExternalAPI() ([]byte, error) {
    // 1. Создаем контекст с таймаутом в 3 секунды
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel() // Всегда вызываем cancel для очистки ресурсов контекста

    // 2. Создаем HTTP-запрос, привязанный к созданному контексту
    req, err := http.NewRequestWithContext(ctx, http.MethodGet, "https://api.github.com/users/octocat", nil)
    if err != nil {
        return nil, err
    }

    client := &http.Client{}

    // 3. Выполняем HTTP-запрос
    resp, err := client.Do(req)
    if err != nil {
        // Если время ожидания вышло, Do вернет ошибку с контекстом
        if ctx.Err() == context.DeadlineExceeded {
            log.Println("HTTP request timed out after 3 seconds")
        }
        return nil, err
    }
    defer resp.Body.Close()

    // 4. Считываем полученные данные
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    return body, nil
}

func main() {
    data, err := fetchExternalAPI()
    if err != nil {
        log.Fatalf("Failed to fetch API: %v", err)
    }
    log.Printf("Successfully fetched %d bytes", len(data))
}

Как это работает: из crypto/rand считываются 16 случайных байт, затем биты версии (4) и варианта устанавливаются по RFC 4122, после чего байты форматируются в стандартные hex-группы 8-4-4-4-12.

package main

import (
    "crypto/rand"
    "fmt"
)

func generateUUID() (string, error) {
    b := make([]byte, 16)
    if _, err := rand.Read(b); err != nil {
        return "", err
    }

    b[6] = (b[6] & 0x0f) | 0x40
    b[8] = (b[8] & 0x3f) | 0x80

    return fmt.Sprintf("%x-%x-%x-%x-%x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:16]), nil
}

// Example usage
id, _ := generateUUID() // "3f9a1c2e-8b3d-4c1a-9f2e-6d8b1a4c7e9f"

Как это работает: wg.Add(1) перед запуском каждой горутины и defer wg.Done() внутри неё держат счётчик сбалансированным; передача url как параметра u (вместо захвата переменной цикла напрямую через замыкание) избегает классической ошибки Go, когда все горутины видят одно и то же, последнее значение переменной цикла.

package main

import (
    "fmt"
    "sync"
)

func processURLs(urls []string) {
    var wg sync.WaitGroup

    for _, url := range urls {
        wg.Add(1)
        go func(u string) {
            defer wg.Done()
            fmt.Println("fetched:", u)
        }(url)
    }

    wg.Wait() // blocks until every goroutine has called wg.Done()
}

Пример создания продакшн-ready HTTP-сервера на Go, который отслеживает сигналы прерывания от ОС (Ctrl+C или сигналы контейнеризации Docker/Kubernetes) и корректно останавливается, давая до 10 секунд на обработку текущих запросов перед выходом.

package main

import (
    "context"
    "errors"
    "log"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        w.Write([]byte("OK"))
    })

    server := &http.Server{
        Addr:    ":8080",
        Handler: mux,
    }

    // Канал для отслеживания системных сигналов
    shutdownChan := make(chan os.Signal, 1)
    signal.Notify(shutdownChan, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)

    // Запуск HTTP-сервера в отдельной горутине
    go func() {
        log.Printf("Starting server on %s", server.Addr)
        if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
            log.Fatalf("ListenAndServe error: %v", err)
        }
    }()

    // Блокируем поток до получения сигнала
    sig := <-shutdownChan
    log.Printf("Received signal: %v. Initiating graceful shutdown...", sig)

    // Таймаут на завершение текущих соединений (10 секунд)
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    // Корректное завершение работы сервера
    if err := server.Shutdown(ctx); err != nil {
        log.Fatalf("Server forced to shutdown: %v", err)
    }

    log.Println("Server stopped cleanly. Releasing database resources...")
    // Здесь можно закрыть соединения с БД, Redis и т.д.
}

Как это работает: http.Get выполняет запрос, io.ReadAll считывает тело ответа в срез байт, а json.Unmarshal декодирует его прямо в типизированную структуру, переданную по указателю.

package main

import (
    "encoding/json"
    "io"
    "net/http"
)

func httpGetJSON(url string, target interface{}) error {
    resp, err := http.Get(url)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return err
    }

    return json.Unmarshal(body, target)
}

// Example usage
type User struct {
    Name string `json:"name"`
}

var user User
err := httpGetJSON("https://api.example.com/users/1", &user)

Как это работает: bufio.Scanner читает файл блоками и отдаёт по одной строке за раз через Scan()/Text(), поэтому потребление памяти остаётся постоянным независимо от размера файла.

package main

import (
    "bufio"
    "fmt"
    "os"
)

func readLines(path string) error {
    file, err := os.Open(path)
    if err != nil {
        return err
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        fmt.Println(scanner.Text())
    }
    return scanner.Err()
}

Как это работает: http.HandleFunc регистрирует обработчик для пути, а http.ListenAndServe запускает сервер и блокирует выполнение — передача nil вторым аргументом указывает использовать стандартный мультиплексор запросов, на котором HandleFunc зарегистрировал роуты.

package main

import (
    "encoding/json"
    "log"
    "net/http"
)

func healthHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
}

func main() {
    http.HandleFunc("/health", healthHandler)
    log.Println("Listening on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}