Go веб-разработка: масштабируемые сервисы с тысячами запросов

package main

import (
"fmt"
"net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Привет, Go! Вы запросили: %s", r.URL.Path)
}

func main() {
http.HandleFunc("/", handler)
fmt.Println("Сервер запущен на порту 8080...")
http.ListenAndServe(":8080", nil)
}

package main

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

// Структура для представления данных пользователя
type User struct {
ID int `json:"id"`
Name string `json:"name"`
Email string `json:"email"`
}

func usersHandler(w http.ResponseWriter, r *http.Request) {
// Создаём примеры пользователей
users := []User{
{ID: 1, Name: "Иван", Email: "ivan@example.com"},
{ID: 2, Name: "Мария", Email: "maria@example.com"},
}

// Устанавливаем заголовок Content-Type
w.Header().Set("Content-Type", "application/json")

// Кодируем данные в JSON и отправляем клиенту
json.NewEncoder(w).Encode(users)
}

func rootHandler(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/" {
http.NotFound(w, r)
return
}
w.Write([]byte("Добро пожаловать на наш API!"))
}

func main() {
// Регистрируем обработчики для разных URL
http.HandleFunc("/", rootHandler)
http.HandleFunc("/api/users", usersHandler)

// Запускаем сервер с логированием ошибок
log.Println("Сервер запущен на http://localhost:8080")
log.Fatal(http.ListenAndServe(":8080", nil))
}

func usersHandler(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")

switch r.Method {
case "GET":
// Возвращаем список пользователей
users := []User{
{ID: 1, Name: "Иван", Email: "ivan@example.com"},
{ID: 2, Name: "Мария", Email: "maria@example.com"},
}
json.NewEncoder(w).Encode(users)

case "POST":
// Создаем нового пользователя
var newUser User
err := json.NewDecoder(r.Body).Decode(&newUser)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}

// В реальном приложении здесь был бы код для сохранения в БД
w.WriteHeader(http.StatusCreated)
json.NewEncoder(w).Encode(newUser)

default:
// Метод не поддерживается
w.WriteHeader(http.StatusMethodNotAllowed)
w.Write([]byte("Метод не поддерживается"))
}
}

package main

import (
"net/http"
"github.com/gin-gonic/gin"
)

// Структура для пользователя
type User struct {
ID string `json:"id"`
Name string `json:"name"`
Email string `json:"email"`
}

// Хранилище пользователей (для примера используем память)
var users = []User{
{ID: "1", Name: "Алексей", Email: "alex@example.com"},
{ID: "2", Name: "Елена", Email: "elena@example.com"},
}

func main() {
// Создаем роутер Gin
r := gin.Default()

// Определяем группу маршрутов для API
api := r.Group("/api")
{
// Получение всех пользователей
api.GET("/users", getUsers)

// Получение пользователя по ID
api.GET("/users/:id", getUserByID)

// Создание нового пользователя
api.POST("/users", createUser)

// Обновление пользователя
api.PUT("/users/:id", updateUser)

// Удаление пользователя
api.DELETE("/users/:id", deleteUser)
}

// Запускаем сервер на порту 8080
r.Run(":8080")
}

// Обработчик для получения всех пользователей
func getUsers(c *gin.Context) {
c.JSON(http.StatusOK, users)
}

// Обработчик для получения пользователя по ID
func getUserByID(c *gin.Context) {
id := c.Param("id")

for _, user := range users {
if user.ID == id {
c.JSON(http.StatusOK, user)
return
}
}

c.JSON(http.StatusNotFound, gin.H{"message": "Пользователь не найден"})
}

// Обработчик для создания пользователя
func createUser(c *gin.Context) {
var newUser User

// Привязываем JSON из запроса к структуре
if err := c.BindJSON(&newUser); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}

// Добавляем пользователя в список
users = append(users, newUser)

c.JSON(http.StatusCreated, newUser)
}

// Обработчик для обновления пользователя
func updateUser(c *gin.Context) {
id := c.Param("id")
var updatedUser User

if err := c.BindJSON(&updatedUser); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}

for i, user := range users {
if user.ID == id {
users[i] = updatedUser
c.JSON(http.StatusOK, updatedUser)
return
}
}

c.JSON(http.StatusNotFound, gin.H{"message": "Пользователь не найден"})
}

// Обработчик для удаления пользователя
func deleteUser(c *gin.Context) {
id := c.Param("id")

for i, user := range users {
if user.ID == id {
users = append(users[:i], users[i+1:]...)
c.JSON(http.StatusOK, gin.H{"message": "Пользователь удален"})
return
}
}

c.JSON(http.StatusNotFound, gin.H{"message": "Пользователь не найден"})
}

package main

import (
"net/http"
"github.com/labstack/echo/v4"
"github.com/labstack/echo/v4/middleware"
)

func main() {
// Создаем экземпляр Echo
e := echo.New()

// Добавляем middleware
e.Use(middleware.Logger())
e.Use(middleware.Recover())

// Определяем маршруты
e.GET("/", hello)

// API маршруты
e.GET("/api/users", getUsers)
e.POST("/api/users", createUser)

// Запускаем сервер
e.Logger.Fatal(e.Start(":8080"))
}

func hello(c echo.Context) error {
return c.String(http.StatusOK, "Привет, Echo!")
}

func getUsers(c echo.Context) error {
users := []map[string]interface{}{
{"id": 1, "name": "Иван"},
{"id": 2, "name": "Мария"},
}
return c.JSON(http.StatusOK, users)
}

func createUser(c echo.Context) error {
u := new(User)
if err := c.Bind(u); err != nil {
return err
}
// Логика создания пользователя
return c.JSON(http.StatusCreated, u)
}

type User struct {
ID int `json:"id"`
Name string `json:"name"`
}

go get github.com/gin-gonic/gin
go get github.com/jmoiron/sqlx
go get github.com/lib/pq

package db

import (
"fmt"
"log"

"github.com/jmoiron/sqlx"
_ "github.com/lib/pq" // PostgreSQL драйвер
)

// ConnectDB устанавливает соединение с базой данных
func ConnectDB() (*sqlx.DB, error) {
// Параметры подключения
const (
host = "localhost"
port = 5432
user = "postgres"
password = "password"
dbname = "task_manager"
)

// Строка подключения
dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",
host, port, user, password, dbname)

// Устанавливаем соединение
db, err := sqlx.Connect("postgres", dsn)
if err != nil {
return nil, err
}

// Проверяем соединение
if err = db.Ping(); err != nil {
return nil, err
}

log.Println("Успешное подключение к базе данных")
return db, nil
}

package models

import "time"

// Task представляет задачу в нашем API
type Task struct {
ID int64 `json:"id" db:"id"`
Title string `json:"title" db:"title"`
Description string `json:"description" db:"description"`
Status string `json:"status" db:"status"`
CreatedAt time.Time `json:"created_at" db:"created_at"`
UpdatedAt time.Time `json:"updated_at" db:"updated_at"`
}

// TaskInput представляет входные данные для создания или обновления задачи
type TaskInput struct {
Title string `json:"title" binding:"required"`
Description string `json:"description"`
Status string `json:"status" binding:"required,oneof=todo in_progress done"`
}

package repository

import (
"time"

"github.com/jmoiron/sqlx"
"github.com/yourusername/taskapi/models"
)

// TaskRepository предоставляет методы для работы с задачами в базе данных
type TaskRepository struct {
db *sqlx.DB
}

// NewTaskRepository создает новый экземпляр репозитория
func NewTaskRepository(db *sqlx.DB) *TaskRepository {
return &TaskRepository{db: db}
}

// GetAll возвращает все задачи
func (r *TaskRepository) GetAll() ([]models.Task, error) {
tasks := []models.Task{}
query := `SELECT * FROM tasks ORDER BY created_at DESC`
err := r.db.Select(&tasks, query)
return tasks, err
}

// GetByID возвращает задачу по ID
func (r *TaskRepository) GetByID(id int64) (models.Task, error) {
var task models.Task
query := `SELECT * FROM tasks WHERE id = $1`
err := r.db.Get(&task, query, id)
return task, err
}

// Create создает новую задачу
func (r *TaskRepository) Create(input models.TaskInput) (models.Task, error) {
var task models.Task
query := `
INSERT INTO tasks (title, description, status, created_at, updated_at)
VALUES ($1, $2, $3, $4, $5)
RETURNING *
`
now := time.Now()
err := r.db.QueryRowx(
query,
input.Title,
input.Description,
input.Status,
now,
now,
).StructScan(&task)

return task, err
}

// Update обновляет существующую задачу
func (r *TaskRepository) Update(id int64, input models.TaskInput) (models.Task, error) {
var task models.Task
query := `
UPDATE tasks
SET title = $1, description = $2, status = $3, updated_at = $4
WHERE id = $5
RETURNING *
`
err := r.db.QueryRowx(
query,
input.Title,
input.Description,
input.Status,
time.Now(),
id,
).StructScan(&task)

return task, err
}

// Delete удаляет задачу по ID
func (r *TaskRepository) Delete(id int64) error {
query := `DELETE FROM tasks WHERE id = $1`
_, err := r.db.Exec(query, id)
return err
}

package handlers

import (
"net/http"
"strconv"

"github.com/gin-gonic/gin"
"github.com/yourusername/taskapi/models"
"github.com/yourusername/taskapi/repository"
)

// TaskHandler обрабатывает HTTP-запросы для задач
type TaskHandler struct {
repo *repository.TaskRepository
}

// NewTaskHandler создает новый экземпляр обработчика
func NewTaskHandler(repo *repository.TaskRepository) *TaskHandler {
return &TaskHandler{repo: repo}
}

// GetTasks возвращает все задачи
func (h *TaskHandler) GetTasks(c *gin.Context) {
tasks, err := h.repo.GetAll()
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}

c.JSON(http.StatusOK, tasks)
}

// GetTask возвращает задачу по ID
func (h *TaskHandler) GetTask(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Некорректный ID"})
return
}

task, err := h.repo.GetByID(id)
if err != nil {
c.JSON(http.StatusNotFound, gin.H{"error": "Задача не найдена"})
return
}

c.JSON(http.StatusOK, task)
}

// CreateTask создает новую задачу
func (h *TaskHandler) CreateTask(c *gin.Context) {
var input models.TaskInput

if err := c.ShouldBindJSON(&input); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}

task, err := h.repo.Create(input)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}

c.JSON(http.StatusCreated, task)
}

// UpdateTask обновляет существующую задачу
func (h *TaskHandler) UpdateTask(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Некорректный ID"})
return
}

var input models.TaskInput
if err := c.ShouldBindJSON(&input); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}

task, err := h.repo.Update(id, input)
if err != nil {
c.JSON(http.StatusNotFound, gin.H{"error": "Задача не найдена или ошибка обновления"})
return
}

c.JSON(http.StatusOK, task)
}

// DeleteTask удаляет задачу
func (h *TaskHandler) DeleteTask(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Некорректный ID"})
return
}

if err := h.repo.Delete(id); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}

c.JSON(http.StatusOK, gin.H{"message": "Задача успешно удалена"})
}

package main

import (
"log"

"github.com/gin-gonic/gin"
"github.com/yourusername/taskapi/db"
"github.com/yourusername/taskapi/handlers"
"github.com/yourusername/taskapi/repository"
)

func main() {
// Подключаемся к базе данных
database, err := db.ConnectDB()
if err != nil {
log.Fatalf("Не удалось подключиться к базе данных: %v", err)
}

// Инициализируем репозиторий
taskRepo := repository.NewTaskRepository(database)

// Инициализируем обработчики
taskHandler := handlers.NewTaskHandler(taskRepo)

// Создаем роутер Gin
router := gin.Default()

// Определяем маршруты API
api := router.Group("/api")
{
tasks := api.Group("/tasks")
{
tasks.GET("", taskHandler.GetTasks)
tasks.GET("/:id", taskHandler.GetTask)
tasks.POST("", taskHandler.CreateTask)
tasks.PUT("/:id", taskHandler.UpdateTask)
tasks.DELETE("/:id", taskHandler.DeleteTask)
}
}

// Запускаем сервер
log.Println("Сервер запущен на порту 8080")
if err := router.Run(":8080"); err != nil {
log.Fatalf("Ошибка запуска сервера: %v", err)
}
}

CREATE TABLE tasks (
id SERIAL PRIMARY KEY,
title VARCHAR(100) NOT NULL,
description TEXT,
status VARCHAR(20) NOT NULL,
created_at TIMESTAMP NOT NULL,
updated_at TIMESTAMP NOT NULL
);

# Этап сборки
FROM golang:1.17-alpine AS builder

WORKDIR /app

# Копируем go.mod и go.sum
COPY go.mod go.sum ./
RUN go mod download

# Копируем исходный код
COPY . .

# Собираем бинарный файл
RUN CGO_ENABLED=0 GOOS=linux go build -a -o api-server .

# Этап выполнения
FROM alpine:3.14

WORKDIR /app

# Копируем бинарный файл из этапа сборки
COPY --from=builder /app/api-server .

# Порт, который будет слушать приложение
EXPOSE 8080

# Запускаем приложение
CMD ["./api-server"]

version: '3'

services:
app:
build:
context: .
ports:
- "8080:8080"
depends_on:
- db
environment:
- DB_HOST=db
- DB_PORT=5432
- DB_USER=postgres
- DB_PASSWORD=password
- DB_NAME=task_manager

db:
image: postgres:13-alpine
ports:
- "5432:5432"
environment:
- POSTGRES_USER=postgres
- POSTGRES_PASSWORD=password
- POSTGRES_DB=task_manager
volumes:
- postgres_data:/var/lib/postgresql/data

volumes:
postgres_data:

docker-compose up -d

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: go-api
spec:
replicas: 3
selector:
matchLabels:
app: go-api
template:
metadata:
labels:
app: go-api
spec:
containers:
- name: go-api
image: your-registry/go-api:latest
ports:
- containerPort: 8080
env:
- name: DB_HOST
value: postgres-service
- name: DB_PORT
value: "5432"
- name: DB_USER
valueFrom:
secretKeyRef:
name: db-credentials
key: username
- name: DB_PASSWORD
valueFrom:
secretKeyRef:
name: db-credentials
key: password
- name: DB_NAME
value: task_manager
resources:
limits:
cpu: "0.5"
memory: "512Mi"
requests:
cpu: "0.2"
memory: "256Mi"
readinessProbe:
httpGet:
path: /health
port: 8080
initialDelaySeconds: 5
periodSeconds: 10

---
# service.yaml
apiVersion: v1
kind: Service
metadata:
name: go-api-service
spec:
selector:
app: go-api
ports:
- port: 80
targetPort: 8080
type: LoadBalancer

package main

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

"github.com/gin-gonic/gin"
)

func main() {
router := gin.Default()
// Настройка маршрутов...

srv := &http.Server{
Addr: ":8080",
Handler: router,
}

// Запуск сервера в отдельной горутине
go func() {
if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
log.Fatalf("Ошибка запуска сервера: %v", err)
}
}()

// Канал для получения сигналов прерывания
quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
<-quit
log.Println("Получен сигнал завершения, выполняется graceful shutdown...")

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

if err := srv.Shutdown(ctx); err != nil {
log.Fatalf("Ошибка при shutdown сервера: %v", err)
}

log.Println("Сервер успешно завершил работу")
}

# main.tf
provider "aws" {
region = "us-west-2"
}

resource "aws_ecs_cluster" "go_cluster" {
name = "go-api-cluster"
}

resource "aws_ecs_task_definition" "go_task" {
family = "go-api-task"
container_definitions = jsonencode([{
name = "go-api-container"
image = "${aws_ecr_repository.go_repo.repository_url}:latest"
essential = true
portMappings = [{
containerPort = 8080
hostPort = 8080
}]
environment = [
{ name = "DB_HOST", value = aws_db_instance.postgres.address },
{ name = "DB_PORT", value = "5432" },
{ name = "DB_NAME", value = "task_manager" }
]
secrets = [
{ name = "DB_USER", valueFrom = aws_secretsmanager_secret.db_username.arn },
{ name = "DB_PASSWORD", valueFrom = aws_secretsmanager_secret.db_password.arn }
]
logConfiguration = {
logDriver = "awslogs"
options = {
"awslogs-group" = aws_cloudwatch_log_group.go_logs.name
"awslogs-region" = "us-west-2"
"awslogs-stream-prefix" = "go-api"
}
}
}])
execution_role_arn = aws_iam_role.ecs_execution_role.arn
task_role_arn = aws_iam_role.ecs_task_role.arn

requires_compatibilities = ["FARGATE"]
network_mode = "awsvpc"
cpu = "256"
memory = "512"
}

resource "aws_ecs_service" "go_service" {
name = "go-api-service"
cluster = aws_ecs_cluster.go_cluster.id
task_definition = aws_ecs_task_definition.go_task.arn
desired_count = 3
launch_type = "FARGATE"

network_configuration {
subnets = aws_subnet.private.*.id
security_groups = [aws_security_group.go_sg.id]
}

load_balancer {
target_group_arn = aws_lb_target_group.go_tg.arn
container_name = "go-api-container"
container_port = 8080
}

depends_on = [aws_lb_listener.go_listener]
}

# Остальные ресурсы: VPC, базы данных, балансировщик нагрузки и т.д.