Перейти к основному содержимому

Пример микросервиса на Go

ДЛЯ НОВИЧКОВНЕ ДЛЯ НОВИЧКОВНЕ ОБЯЗАТЕЛЬНОВ РАЗРАБОТКЕ
Разработчику Архитектору

Пример микросервиса на Go​

Важно
Предварительно рекомендую познакомиться с Docker.

Микросервис на языке Go демонстрирует принципы контейнеризации и быстрого развертывания приложений. Использование стандартных инструментов позволяет создать надежную среду разработки и эксплуатации. Следующие шаги могут включать добавление базы данных, настройку балансировки нагрузки или интеграцию с системой мониторинга.

Установка инструментов разработки​

Процесс создания и запуска микросервиса начинается с подготовки окружения. Для работы потребуется установить компилятор языка Go, инструмент для управления сборками и программу для контейнеризации Docker.

Установка среды разработки происходит в несколько этапов. Сначала необходимо получить сам язык программирования. Официальный сайт проекта предоставляет инструкции для различных операционных систем. Пользователь скачивает архив или установщик, распаковывает его в системную директорию и добавляет путь к исполняемым файлам в переменную окружения PATH. После установки можно проверить корректность работы команды go version в терминале. Система отобразит версию установленного компилятора.

Следующим шагом является установка Docker. Эта программа позволяет создавать изолированные среды выполнения приложений. Установщик Docker Desktop автоматически настроит виртуальную машину или подсистему Linux в зависимости от используемой операционной системы. После завершения инсталляции приложение должно быть запущено, чтобы инициализировать демон фоновых процессов. Проверка работоспособности осуществляется командой docker --version.

Пользователю следует убедиться, что оба инструмента доступны из командной строки. Отсутствие ошибок при запуске проверочных команд подтверждает готовность среды к дальнейшим действиям. В случае возникновения проблем с правами доступа или путями поиска программ требуется перезапуск терминала или повторная проверка настроек переменных окружения.

Создание структуры проекта​

Файловая структура проекта должна соответствовать стандартам организации кода в экосистеме Go. Корневая директория содержит исходные файлы, конфигурационные скрипты и документацию. Внутри корня создается файл main.go, который служит точкой входа для приложения.

Первым действием является создание новой папки для проекта. Команда mkdir my-microservice создаст директорию с указанным именем. Переход внутрь этой директории осуществляется командой cd my-microservice. Внутри созданной папки нужно инициализировать модуль Go. Это действие создает файл go.mod, который описывает зависимости проекта и его имя. Команда go mod init my-microservice генерирует этот файл.

Структура файлов выглядит следующим образом:

  • my-microservice/ — корневая папка проекта;
  • main.go — основной файл с логикой сервера;
  • Dockerfile — инструкция для сборки образа контейнера;
  • go.mod — описание зависимостей модуля;
  • go.sum — контрольные суммы зависимостей (генерируется автоматически).

Такая организация позволяет легко масштабировать проект, добавлять новые пакеты и поддерживать порядок в коде. Использование стандартной структуры упрощает работу других разработчиков и автоматизированных систем сборки.

Написание кода сервера​

Файл main.go содержит реализацию простого HTTP-сервера, который обрабатывает входящие запросы и возвращает ответ клиенту. Код написан с использованием стандартной библиотеки net/http, которая входит в состав базового дистрибутива Go.

Приложение регистрирует обработчик для корневой URL-адреса /. При поступлении запроса сервер выполняет функцию обработки, которая формирует текстовый ответ. Функция http.HandleFunc связывает путь с функцией-обработчиком. Вызов функции http.ListenAndServe запускает сервер на указанном порту.

package main

import (
	"fmt"
	"net/http"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Привет! Это микросервис на Go, работающий внутри контейнера.")
}

func main() {
	http.HandleFunc("/", helloHandler)
	fmt.Println("Сервер запущен на порту 8080")
	err := http.ListenAndServe(":8080", nil)
	if err != nil {
		fmt.Printf("Ошибка запуска сервера: %v\n", err)
	}
}

В приведенном примере используется функция fmt.Fprintf для записи данных в объект ResponseWriter. Этот объект представляет собой поток вывода ответа HTTP. Строка "Привет! Это микросервис на Go..." отправляется браузеру пользователя.

Функция main инициирует цикл обработки событий. Метод ListenAndServe блокирует выполнение программы до момента остановки сервера. Параметр :8080 указывает порт, на котором будет слушаться трафик. Если порт занят или недоступен, система вернет ошибку, которую код выводит в консоль через fmt.Printf.

Для проверки корректности кода можно выполнить команду go build. Компилятор проверит синтаксис и соберет исполняемый файл. Запуск собранного файла без Docker позволит протестировать логику в локальном окружении.

Конфигурация Dockerfile​

Файл Dockerfile определяет инструкцию для создания образа контейнера. Он содержит последовательность шагов по подготовке окружения, копированию кода и настройке запуска. Использование многоступенчатой сборки уменьшает размер итогового образа, исключая лишние инструменты разработки из финальной версии.

Первый этап сборки использует официальный образ Go как основу для компиляции. Эта стадия называется builder. Она загружает образ с установленным компилятором и инструментами. Затем в образ копируются файлы проекта. Команда RUN go build -o /app/main . собирает исполняемый файл и помещает его в директорию /app.

Второй этап использует легкий образ Alpine Linux. Этот образ содержит только необходимые системные библиотеки, что делает его минимальным по размеру. Копирование исполняемого файла из предыдущего этапа в текущий образ происходит через команду COPY --from=builder /app/main /app/main.

Финальная инструкция CMD указывает, какую команду выполнять при запуске контейнера. В данном случае это запуск собранного бинарного файла /app/main. Образ также объявляет порт 8080 как открытый для внешних подключений.

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

WORKDIR /app

# Копирование файлов модуля
COPY go.mod ./
RUN go mod download

# Копирование исходного кода
COPY . .

# Сборка приложения
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o main .

# Этап запуска
FROM alpine:latest

WORKDIR /root/

# Копирование скомпилированного бинарника
COPY --from=builder /app/main .

# Открытие порта
EXPOSE 8080

# Команда запуска
CMD ["./main"]

Использование переменной окружения CGO_ENABLED=0 отключает связь с C-библиотеками, что позволяет создать полностью статический бинарный файл. Такой файл не требует наличия дополнительных библиотек в целевом образе и работает быстрее. Образ Alpine обеспечивает безопасность и экономию места на диске.

Сборка и запуск контейнера​

Процесс сборки образа выполняется командой docker build. Она считывает файл Dockerfile и выполняет все указанные шаги последовательно. Результатом является новый образ с уникальным идентификатором или тегом.

Команда docker build -t my-go-service . создает образ с именем my-go-service. Точка в конце команды указывает на текущую директорию, где находится Dockerfile. Процесс сборки может занять несколько минут в зависимости от скорости интернета и производительности машины. Логи процесса отображаются в терминале, показывая статус каждого шага.

После успешной сборки образ появляется в списке локальных образов. Команда docker images отображает список всех доступных образов с их тегами и размером.

Запуск контейнера осуществляется командой docker run. Параметр -p 8080:8080 пробрасывает порт 8080 хост-машины в порт 8080 контейнера. Флаг --rm удаляет контейнер после его остановки, поддерживая чистоту системы.

docker run -p 8080:8080 --rm my-go-service

При запуске система выведет сообщение "Сервер запущен на порту 8080". Это подтверждает, что приложение успешно стартовало внутри изолированной среды. Контейнер остается активным и ожидает входящих запросов.

Если требуется остановить контейнер вручную, достаточно нажать комбинацию клавиш Ctrl+C в терминале. Система завершит процесс и удалит контейнер благодаря флагу --rm.

Проверка работы сервиса​

Для проверки работоспособности микросервиса необходимо открыть веб-браузер и перейти по адресу http://localhost:8080. Браузер отправит HTTP-запрос на указанный порт. Сервер внутри контейнера обработает запрос и вернет текстовое сообщение.

На экране браузера отобразится следующий текст:

Привет! Это микросервис на Go, работающий внутри контейнера.

Отсутствие ошибок загрузки страницы означает, что сеть между хост-машиной и контейнером настроена корректно. Порт 8080 открыт и доступен для внешнего подключения.

Альтернативный способ проверки — использование утилиты curl в терминале. Команда curl http://localhost:8080 выведет ответ сервера непосредственно в консоль. Это удобно для автоматизации тестов или проверки в среде без графического интерфейса.

curl http://localhost:8080

Результат выполнения команды совпадает с тем, что отображается в браузере. Такая проверка подтверждает полную функциональность микросервиса и корректность настройки Docker.

Освоение главы0%