Использование Air в Go для реализации live reloading

Перевод статьи Using Air with Go to implement live reload

live reloading — это полезная функция, которая позволяет разработчикам видеть изменения в режиме реального времени во время работы над кодом. Это может сэкономить много времени, поскольку устраняет необходимость вручную останавливать и перезапускать сервер каждый раз, когда вы вносите изменения.

В Go существует несколько фреймворков для этого, которые вы можете использовать для автоматической перезагрузки приложения всякий раз, когда вы вносите изменения в исходный код. В этом посте будет рассмотрено, как использовать библиотеку Air для реализации live reloading в Go.

Содержание:

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

Зачем использовать живую перезагрузку в Go?

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

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

Оперативная перезагрузка также может быть полезна для отладки. Автоматическая перезагрузка приложения при внесении изменений позволяет быстрее выявлять и устранять проблемы.

Это особенно полезно при работе с приложениями, которые сложно отлаживать, например со сложными зависимостями или длительным временем запуска.

Live reload vs. hot reload в Go

В Go live reloading «живая перезагрузка» означает возможность автоматически перезагружать и обновлять приложение без необходимости останавливать и перезапускать его вручную.

Hot reloading «uорячая перезагрузка» — аналогичная концепция, но конкретно относится к возможности обновлять код приложения во время его работы — без прерывания его текущего состояния или каких-либо текущих процессов.

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

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

Go and Gin projects do not have native support for live reload functionality, so let’s see how to set up the Air library to implement live reload in Go and Gin projects.

Проекты Go и Gin не имеют встроенной поддержки функции перезагрузки в реальном времени, поэтому давайте посмотрим, как настроить библиотеку Air для реализации перезагрузки в реальном времени в проектах Go и Gin.

Знакомство с библиотекой Air для приложений Go

Air — это утилита командной строки с перезагрузкой в реальном времени для приложений Go, находящихся в разработке. Это инструмент командной строки, который позволяет приложениям Go перезагружаться в режиме реального времени.

Помимо Air, другие популярные фреймворки с живой перезагрузкой для Go включают Fresh и Realize. Все они работают одинаково — автоматически перестраивают и перезапускают ваше приложение всякий раз, когда обнаруживают изменения в исходном коде.

Fresh — это еще один инструмент командной строки, предназначенный для использования с любым веб-сервером Go, который легко интегрировать в процесс сборки.

Realize — это система сборки на основе Go, которая обеспечивает функцию оперативной перезагрузки для приложений Go.

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

Руководство по использованию Air в проектах Go и Gin

Вы можете легко начать работу с проектами Air в Go с Gin, выполнив следующие пять шагов. Сначала установите инструмент Air cli, выполнив следующую команду:

go get -u github.com/cosmtrek/air

Затем установите веб-фреймворк Gin, выполнив следующую команду:

go get -u github.com/gin-gonic/gin

Создайте файл main.go и объявите простую команду Hello, World! конечная точка в Джине:

package main

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

func main() {
    r := gin.Default()
    r.GET("/", func(c *gin.Context) {
        c.String(200, "Hello, World!")
    })
    r.Run()
}

Создайте файл .air.toml в корне вашего проекта. Этот файл будет использоваться для настройки Air. Вы можете использовать следующие параметры конфигурации:

root = "."
testdata_dir = "testdata"
tmp_dir = "tmp"

[build]
  args_bin = []
  bin = "./tmp/main"
  cmd = "go build -o ./tmp/main ."
  delay = 1000
  exclude_dir = ["assets", "tmp", "vendor", "testdata"]
  exclude_file = []
  exclude_regex = ["_test.go"]
  exclude_unchanged = false
  follow_symlink = false
  full_bin = ""
  include_dir = []
  include_ext = ["go", "tpl", "tmpl", "html"]
  kill_delay = "0s"
  log = "build-errors.log"
  send_interrupt = false
  stop_on_error = true

[color]
  app = ""
  build = "yellow"
  main = "magenta"
  runner = "green"
  watcher = "cyan"

[log]
  time = false

[misc]
  clean_on_exit = false

[screen]
  clear_on_rebuild = false

Наконец, запустите приложение Gin из терминала с помощью Air:

air

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

Руководство по использованию Air с контейнерами Docker

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

Это может быть особенно полезно при разработке и тестировании приложений внутри контейнера, поскольку помогает быстрее и проще выявлять и устранять проблемы.

Чтобы использовать библиотеку динамической перезагрузки с Docker, вам необходимо смонтировать локальный каталог исходного кода как том в контейнере Docker. Это позволит библиотеке Air отслеживать изменения в вашем коде и автоматически перезагружать сервер при необходимости.

Сначала создайте Dockerfile с инструкциями по установке и запуску Air:

FROM golang:latest

# Set the current working directory inside the container
WORKDIR /app

# Copy go.mod and go.sum files to the workspace
COPY go.mod go.sum ./

# Download all dependencies
RUN go mod download

# Copy the source from the current directory to the workspace
COPY . .

# Build the Go app
RUN go build -o main .

# Expose port 8080 to the outside world
EXPOSE 8080

# Command to run the executable
CMD ["air"]

Затем создайте файл .air.toml в корне вашего проекта, содержащий следующее:

root = "."
testdata_dir = "testdata"
tmp_dir = "tmp"

[build]
  args_bin = []
  bin = "./tmp/main"
  cmd = "go build -o ./tmp/main ."
  delay = 1000
  exclude_dir = ["assets", "tmp", "vendor", "testdata"]
  exclude_file = []
  exclude_regex = ["_test.go"]
  exclude_unchanged = false
  follow_symlink = false
  full_bin = ""
  include_dir = []
  include_ext = ["go", "tpl", "tmpl", "html"]
  kill_delay = "0s"
  log = "build-errors.log"
  send_interrupt = false
  stop_on_error = true

[color]
  app = ""
  build = "yellow"
  main = "magenta"
  runner = "green"
  watcher = "cyan"

[log]
  time = false

[misc]
  clean_on_exit = false

[screen]
  clear_on_rebuild = false

Чтобы создать образ Docker, выполните следующую команду:

docker build -t airy-app .

Это создаст образ Docker под названием gin-app, который вы сможете использовать для запуска своего сервера Gin. Чтобы запустить сервер в контейнере Docker, используйте следующую команду:

docker run -p 8080:8080 -v $PWD:/app airy-app

Это запустит сервер Gin в контейнере Docker и предоставит ему доступ к порту 8080. Затем вы сможете получить доступ к серверу по адресу http://localhost:8080.

Заключение

Air — это инструмент живой перезагрузки Go, который позволяет разработчикам автоматически перекомпилировать и запускать свой код каждый раз, когда они вносят изменения.