Cómo agilizar el desarrollo de Go con Makefiles

En el desarrollo de software moderno, la automatización de compilación eficiente es crucial para el éxito de un proyecto. Makefiles, una popular herramienta de automatización de compilación, brinda a los desarrolladores de todas las pilas una forma concisa y poderosa de administrar procesos de compilación complejos.

Al integrar e interoperar Makefiles con Go, puede automatizar tareas repetitivas, agilizar los procesos de creación y mejorar la productividad.

Comprender los archivos MAKE

Comprender cómo funcionan los Makefiles es crucial para organizar y automatizar de manera eficiente las compilaciones de su proyecto.

Los archivos MAKE siguen una estructura y sintaxis específicas para definir reglas para crear y mantener proyectos. Básicamente, un Makefile consta de reglas que especifican objetivos, dependencias y comandos. Cada regla comienza con un objetivo, seguido de sus dependencias y los comandos necesarios para construir o ejecutar el objetivo.

Los destinos representan los archivos de salida deseados o las acciones para el Makefile. Los objetivos pueden ser nombres de archivo o etiquetas que describan la tarea. Por ejemplo, un objetivo llamado limpio puede eliminar archivos innecesarios generados durante el proceso de compilación.

Las dependencias son archivos o tareas necesarias para crear un objetivo. Si se modifica alguna dependencia, Makefile reconstruirá los objetivos asociados para garantizar que las partes necesarias del proyecto funcionen. Deberá especificar las dependencias después del destino, separadas por espacios.

Los comandos son acciones o comandos de shell que necesitan ejecución para construir o realizar objetivos específicos. Los comandos generalmente se escriben en un lenguaje de secuencias de comandos de shell del sistema operativo.

Cada comando debe comenzar con un carácter de tabulación para su reconocimiento.

construir: main.go utils.go
 ir a compilar -o myapp main.go utils.go
limpio:
 rm mi aplicación

En el Makefile anterior, hay dos objetivos: construir y limpio.

El construir objetivo depende de la principal.ir y utils.go archivos, y el comando asociado se ejecuta en el compilador Go para construir un ejecutable llamado miaplicacion.

Por otro lado, el limpio objetivo elimina el miaplicacion ejecutable.

Para compilar su código Go, navegue hasta el directorio de trabajo y ejecute el hacer construir dominio.

hacer construir

La herramienta Make se encargará del proceso de compilación, permitiéndole concentrarse en escribir código.

Configuración de Makefiles para sus proyectos Go

Puede usar Makefiles para crear y compilar sus programas, realizar pruebas de código y controles de calidad, y para la integración y el despliegue continuos.

Ejecute este comando para crear un Makefile para su proyecto en el directorio raíz. El Makefile servirá como punto de entrada para definir sus tareas de compilación.

toque Makefile

Su Makefile no debería tener ninguna extensión.

Después de crear el Makefile, puede escribir comandos, dependencias y objetivos en el archivo para las operaciones de su proyecto.

Aquí hay un Makefile de ejemplo que sirve como una herramienta de automatización de compilación para su proyecto:

# Makefile
# Variables
GOCMD=ir
GOBUILD=$(GOCMD) construir
GOTEST=$(GOCMD) prueba
GOLIMPIAR=$(GOCMD) limpio
# Objetivos
construir:
$(GOCONSTRUIR) -o aplicación.
prueba:
$(GOTEST) ./...
limpio:
$(GOLIMPIAR)
 aplicación rm -f

Puede personalizar su Makefile según las necesidades específicas de su proyecto.

Aquí hay una versión modificada del Makefile para pasar indicadores adicionales y variables de entorno durante el proceso de prueba o construcción de su proyecto:

# Makefile
# Variables
GOCMD=ir
GOBUILD=$(GOCMD) construir
GOTEST=$(GOCMD) prueba
GOLIMPIAR=$(GOCMD) limpio
BINARY_NAME=aplicación
TEST_FLAGS=-v
# Objetivos
construir:
$(GOCONSTRUIR) -o $(NOMBRE_BINARIO) .
prueba:
$(GOTEST)$(TEST_FLAGS) ./...
limpio:
$(GOLIMPIAR)
 rm-f $(NOMBRE_BINARIO)

En este Makefile, hay dos nuevas variables llamadas NOMBRE_BINARIO y PRUEBA_BANDERAS. El NOMBRE_BINARIO La variable especifica el nombre del archivo ejecutable generado.

El PRUEBA_BANDERAS variable le permite especificar indicadores adicionales al ejecutar pruebas (en este caso, el -v marca habilita la salida detallada durante la ejecución de la prueba).

Makefiles también proporciona una manera fácil de configurar variables de entorno y banderas para su proyecto.

Puede agregar estas líneas a su Makefile si necesita configurar el GOOS y GOARCH variables para construir su proyecto para un sistema operativo o arquitectura específicos.

# Makefile
# Variables
GOCMD=ir
GOBUILD=$(GOCMD) construir
GOTEST=$(GOCMD) prueba
GOLIMPIAR=$(GOCMD) limpio
BINARY_NAME=aplicación
TEST_FLAGS=-v
GOOS=linux
GOARCH=amd64
# Objetivos
construir:
$(GOCONSTRUIR) -o $(NOMBRE_BINARIO) .
prueba:
$(GOTEST)$(TEST_FLAGS) ./...
limpio:
$(GOLIMPIAR)
 rm-f $(NOMBRE_BINARIO)

En el Makefile actualizado, hay dos nuevas variables para el GOOS y GOARCH variables de entorno que le permiten especificar el sistema operativo de destino y la arquitectura para su compilación (en este caso, el GOOS variable se establece en linux y GOARCH a amd64 para construir el proyecto para Linux en la arquitectura x86-64).

Recuerde adaptar estas variables en función de los requisitos específicos de su proyecto.

Puedes referirte a la Ir documentación para la lista de valores admitidos para GOOS y GOARCH si necesita construir para una plataforma diferente.

Automatización de compilación con archivos MAKE

Los archivos MAKE también son útiles para compilar código, generar documentación y administrar dependencias.

Con Makefiles, puede automatizar el tiempo de compilación, ahorrándole tiempo y esfuerzo.

Aquí hay un Makefile que compila un programa Go:

# Definir variables
GOCMD = ir
CONSTRUIR = $(GOCMD) construir
BINARY_NAME = miprograma
# Objetivo predeterminado
todo: construir
# Crear objetivo
construir:
$(GOCONSTRUIR) -o $(NOMBRE_BINARIO)
# Objetivo limpio
limpio:
 rm-f $(NOMBRE_BINARIO)

El Makefile define variables como el GOCMD (el comando Ir) y GOBUILD (el comando de compilación). El construir el objetivo invoca el ir a construir Comando para compilar nuestro programa Go y producir el binario con el nombre especificado (mi programa en este caso). El limpio target elimina el binario generado del proyecto.

Puede usar Makefiles para automatizar la instalación de dependencias y mantener actualizadas las dependencias externas de su proyecto.

# Definir variables
GOCMD = ir
CONSTRUIR = $(GOCMD) construir
GOGET = $(GOCMD) conseguir
BINARY_NAME = miprograma
# Objetivo predeterminado
todo: construir
# Crear objetivo
construir:
$(GOCONSTRUIR) -o $(NOMBRE_BINARIO)
# Instalar dependencias
deps:
$(GOGET) -tu
# Objetivo limpio
limpio:
 rm-f $(NOMBRE_BINARIO)

El Makefile tiene un deps objetivo que utiliza el ir a buscar comando para instalar o actualizar las dependencias del proyecto. Tu puedes correr hacer deps para instalar las dependencias de su proyecto.

Makefiles puede automatizar la generación de documentación y mejorar su documentos como proceso de código.

Así es como puedes genere documentación automáticamente para sus proyectos Go con la herramienta godoc y Makefile:

# Definir variables
GODOC = godoc
DOCS_DIR = documentos
# Objetivo predeterminado
todos: documentos
# Generar documentación
documentos:
$(GODOC) -html -dir. > $(DOCS_DIR)/index.html
# Objetivo limpio
limpio:
 rm-rf $(DOCS_DIR)

En el Makefile, el documentos el objetivo invoca el godoc comando con el -html marca para generar documentación HTML para su código go y guarda la documentación en el documentos directorio.

Ejecutarás el hacer documentos comando para generar documentación actualizada para su proyecto Go.

Los archivos MAKE son útiles para trabajar con sistemas operativos basados ​​en Unix

Al aprovechar la flexibilidad de Makefiles, puede definir comandos de compilación personalizados y ejecutar tareas complejas en cuestión de minutos. Makefile ahorra tiempo y garantiza la coherencia y la reproducibilidad en todos los entornos de construcción.

Otra ventaja de Makefiles es su compatibilidad con sistemas basados ​​en Unix. Make es una utilidad ampliamente compatible con los sistemas operativos basados ​​en Unix, incluidos Linux y macOS, lo que la convierte en una herramienta portátil y confiable para los desarrolladores.