Makefile, el archivo que te ayuda a ser más productivo.

Ejemplo de archivo Makefile para automatizar algunas de las tareas necesarias en un proyecto de BackEnd. 

#!/bin/bash

UID = $(shell id -u)
DOCKER_BE = design-patterns-in-php

help: ## Show this help message
    @echo 'usage: make [target]'
    @echo
    @echo 'targets:'
    @echo '------------------------------------------------'
    @egrep '^(.+)\:\ ##\ (.+)' ${MAKEFILE_LIST} | column -t -c 2 -s ':#'
    @echo '------------------------------------------------'

start: ## Start the containers
    cp -n docker-compose.yml.dist docker-compose.yml || true
    U_ID=${UID} docker-compose up -d

stop: ## Stop the containers
    U_ID=${UID} docker-compose stop

restart: ## Restart the containers
    $(MAKE) stop && $(MAKE) start

build: ## Rebuilds all the containers
    cp -n docker-compose.yml.dist docker-compose.yml || true
    U_ID=${UID} docker-compose build

prepare-local: ## Installs PHP dependencies using Composer in local
    composer install && composer update

prepare-container: ## Installs PHP dependencies using Composer in the Container
    U_ID=${UID} docker exec -it --user ${UID} ${DOCKER_BE} composer install && composer update

ssh: ## bash into the BackEnd container
    U_ID=${UID} docker exec -it --user ${UID} ${DOCKER_BE} bash

1. Automatización de Tareas Comunes

El Makefile te permite automatizar comandos que ejecutas frecuentemente en tu proyecto. En lugar de recordar comandos largos o complejos, puedes simplemente usar make para ejecutar una tarea. Esto es especialmente útil en equipos, ya que asegura que todos los miembros ejecuten los mismos comandos de manera uniforme.

2. Definición de Variables

UID = $(shell id -u)
DOCKER_BE = design-patterns-in-php

• UID: Esta variable guarda el ID del usuario que ejecuta el script. Esto es útil para asegurar que los comandos dentro de Docker se ejecuten con los mismos permisos que el usuario que los inicia.
• DOCKER_BE: Define el nombre del contenedor de backend (design-patterns-in-php), que se usa en otros comandos.

3. Comandos Definidos

Cada sección con un nombre seguido de : define un "target" en el Makefile. Aquí te explico cada uno:

• help: Muestra una ayuda básica sobre los comandos disponibles en el Makefile. Puedes ejecutar make help para ver un resumen de las opciones disponibles.

• start: Inicia los contenedores Docker. Si el archivo docker-compose.yml no existe, lo copia desde docker-compose.yml.dist y luego levanta los contenedores en segundo plano (-d).

• stop: Detiene los contenedores Docker. Se utiliza el UID para asegurar que el contenedor se detenga con los permisos correctos.

• restart: Primero detiene los contenedores y luego los vuelve a iniciar. Es útil para reiniciar todo rápidamente.

• build: Reconstruye los contenedores Docker. Este comando es útil si has hecho cambios en la configuración de Docker o en la aplicación que requieren una nueva construcción de los contenedores.

• prepare-local: es un target que ejecuta comandos relacionados con la instalación y actualización de dependencias de PHP usando Composer en tu máquina local.

  • composer install: Instala las dependencias definidas en el archivo composer.json en tu proyecto. Si existe un archivo composer.lock, Composer intentará instalar las versiones exactas especificadas en ese archivo.
  • composer update: Actualiza las dependencias a las versiones más recientes permitidas por las restricciones en composer.json. Este comando también actualizará el archivo composer.lock con las nuevas versiones instaladas.
    • Usa make prepare-local cuando quieras instalar y actualizar las dependencias de PHP directamente en tu entorno de desarrollo local, es decir, fuera de cualquier contenedor Docker.

• prepare-container: es un target que realiza la instalación y actualización de las dependencias de PHP usando Composer, pero dentro de un contenedor Docker.

  • U_ID=${UID} docker exec -it --user ${UID} ${DOCKER_BE} composer install: Ejecuta composer install dentro del contenedor Docker especificado por la variable ${DOCKER_BE} (que en tu caso, es el contenedor llamado design-patterns-in-php). Se ejecuta el comando como el usuario con el mismo UID que el usuario en tu máquina local, lo que ayuda a evitar problemas de permisos.
  • && composer update: Después de instalar las dependencias, actualiza las mismas, igual que en prepare-local, pero también dentro del contenedor.
  • Usa make prepare-container cuando desees instalar y actualizar las dependencias de PHP dentro del contenedor Docker que utiliza tu proyecto. Esto es útil cuando tu entorno de desarrollo está configurado para correr dentro de Docker, y necesitas que las dependencias estén instaladas en el sistema de archivos del contenedor.

• ssh: Te permite acceder a la terminal (bash) dentro del contenedor de backend (${DOCKER_BE}). Esto es útil para depuración o para ejecutar comandos manualmente dentro del contenedor.

4. Beneficios en tu Proyecto

• Estandarización: Cualquiera que trabaje en el proyecto puede usar los mismos comandos, reduciendo errores y asegurando que todos sigan el mismo proceso.
• Eficiencia: Evita tener que recordar y escribir comandos largos o complicados, lo que acelera tu flujo de trabajo.
• Documentación: El Makefile actúa como una forma de documentación, indicando cómo deben ejecutarse las tareas importantes del proyecto.

Cómo Usarlo

• Ejecuta make para cualquier tarea definida. Por ejemplo, make start para iniciar los contenedores o make ssh para entrar en el contenedor backend.
• make prepare-local ejecuta los comandos Composer directamente en tu entorno local.
• make prepare-container ejecuta los mismos comandos dentro de un contenedor Docker específico.

  • Estos dos targets te permiten flexibilidad para manejar dependencias según el entorno en el que estés trabajando: si trabajas localmente, usa prepare-local; si trabajas en un entorno Docker, usa prepare-container. De esta manera, aseguras que las dependencias de tu proyecto estén configuradas correctamente sin importar el entorno en el que estés desarrollando.

En resumen, este Makefile te sirve para simplificar, automatizar y estandarizar el manejo de contenedores Docker y otras tareas relacionadas con el entorno de desarrollo de tu proyecto.

Autor: Óscar H Caballero (Senior BackEnd Developer)