Automatiza tus tareas de desarrollo con scripts y herramientas DevOps

¿Tus clientes escriben por WhatsApp y no reciben respuesta? Descubre cómo una solución multiagente evita mensajes perdidos, mejora tiempos de respuesta y convierte más ventas.
CONTÁCTANOS

La automatización reduce errores, acelera entregas y libera tiempo para tareas de mayor impacto. Aquí tienes un playbook práctico para estandarizar tu flujo de trabajo con scripts, ganchos de Git, pipelines CI/CD, contenedores y verificación de calidad.

---

Principios clave

1. Automatiza lo repetible: instalación, build, pruebas, despliegue.
2. Todo como código: pipelines, infra, políticas, linters.
3. Idempotencia: correr dos veces produce el mismo resultado.
4. Shift-left: detecta fallas en la laptop del dev, no en producción.
5. Estandariza comandos: el mismo make test o npm run test en todos los proyectos.

---

Qué automatizar a lo largo del ciclo de vida

1) Onboarding y setup local

• Script único para preparar el entorno, variables y dependencias.

#!/usr/bin/env bash
set -euo pipefail
echo "▶ Bootstrapping..."
# Node
if command -v nvm >/dev/null; then nvm use; fi
npm ci
# Python
python3 -m venv .venv && source .venv/bin/activate && pip install -r requirements.txt
# Env
cp -n .env.example .env || true
echo "✅ Ready. Try: make test"

2) Convenciones y calidad

• Formato, lint y pruebas deben ser comandos simples.

// package.json
{
  "scripts": {
    "fmt": "prettier --write \"**/*.{ts,js,json,md,yml,yaml,css,html}\"",
    "lint": "eslint \"src/**/*.{ts,js}\"",
    "test": "vitest run --coverage"
  }
}

# .pre-commit-config.yaml (usa pre-commit)
repos:
- repo: https://github.com/pre-commit/pre-commit-hooks
  rev: v4.6.0
  hooks:
    - id: end-of-file-fixer
    - id: trailing-whitespace
- repo: https://github.com/psf/black
  rev: 24.8.0
  hooks:
    - id: black

3) Build y empaquetado

• Builds reproducibles con Docker multi-stage o Gradle/Maven.

# Dockerfile (Node + multi-stage)
FROM node:20 AS deps
WORKDIR /app
COPY package*.json ./
RUN npm ci

FROM node:20 AS build
WORKDIR /app
COPY --from=deps /app/node_modules node_modules
COPY . .
RUN npm run build

FROM gcr.io/distroless/nodejs20
WORKDIR /app
COPY --from=build /app/dist dist
CMD ["dist/server.js"]

4) Versionado y changelog

• Versionado semántico y changelog automático.

# scripts/release.sh
set -e
level=${1:-patch} # major|minor|patch
npm version "$level" -m "chore(release): %s"
conventional-changelog -p angular -i CHANGELOG.md -s
git add CHANGELOG.md
git commit -m "docs(changelog): update"
git push --follow-tags

5) Seguridad

• Escaneo de dependencias y secretos en cada commit.

# .gitlab-ci.yml (fragmento)
stages: [verify, build, test]
sast:
  stage: verify
  image: registry.gitlab.com/gitlab-org/security-products/analyzers/sast:latest
  script: ["analyzer run"]
  artifacts: { when: always, reports: { sast: gl-sast-report.json } }

secret_detection:
  stage: verify
  image: registry.gitlab.com/gitlab-org/security-products/analyzers/secret-detection:latest
  script: ["/analyzer run"]

6) CI/CD mínima y portable

• Define los mismos targets en Make y reúsalos en CI.

# Makefile
.PHONY: setup fmt lint test build run docker
setup: ; ./scripts/bootstrap.sh
fmt: ; npm run fmt
lint: ; npm run lint
test: ; npm run test
build: ; npm run build
run: ; node dist/server.js
docker: ; docker build -t myapp:local .

# .github/workflows/ci.yml
name: ci
on: [push, pull_request]
jobs:
  build_test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: 20, cache: 'npm' }
      - run: npm ci
      - run: make fmt lint test build

# .gitlab-ci.yml
stages: [verify, build, test, package]
cache:
  paths: [node_modules/]
verify:
  stage: verify
  image: node:20
  script:
    - npm ci
    - make fmt lint
test:
  stage: test
  image: node:20
  script: [ "npm test -- --coverage" ]
build:
  stage: build
  image: node:20
  script: [ "npm run build" ]
package:
  stage: package
  image: docker:27
  services: [docker:27-dind]
  variables: { DOCKER_DRIVER: overlay2 }
  script:
    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA .
    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA

7) Entornos y configuración

• .env administrado con plantillas y validación.

// src/config.ts
import * as z from "zod";
const Env = z.object({
  NODE_ENV: z.enum(["development", "test", "production"]),
  PORT: z.string().transform(Number).default("3000"),
  DATABASE_URL: z.string().url(),
});
export const env = Env.parse(process.env);

8) Observabilidad y post-deploy

• Scripts para migraciones, seeds, healthcheck y rollback.

# scripts/post-deploy.sh
set -e
echo "▶ Running migrations..."
npm run migrate
echo "▶ Healthcheck..."
curl -fsS http://$HOST/health || (echo "healthcheck failed" && exit 1)
echo "✅ Post-deploy OK"

---

Obtén descuentos exclusivos de nuestros cursos en vivo en línea

Capacítate con los expertos

Quiero recibir noticias

Por favor clic en quiero recibir noticias.

Email es requerido.

x

You Have Successfully Subscribed to the Newsletter

Plantilla de estructura de proyecto

.
├─ scripts/
│  ├─ bootstrap.sh
│  ├─ release.sh
│  └─ post-deploy.sh
├─ .github/workflows/ci.yml      # o .gitlab-ci.yml
├─ Dockerfile
├─ docker-compose.yml
├─ Makefile
├─ .pre-commit-config.yaml
├─ .env.example
├─ CHANGELOG.md
└─ src/

docker-compose.yml para desarrollo local:

services:
  api:
    build: .
    command: node dist/server.js
    ports: ["3000:3000"]
    env_file: .env
    depends_on: [db]
  db:
    image: postgres:16
    environment:
      POSTGRES_USER: app
      POSTGRES_PASSWORD: app
      POSTGRES_DB: appdb
    ports: ["5432:5432"]

---

Roadmap 30/60/90

• Día 1–30: Makefile, scripts de bootstrap, pre-commit, lint, test, Dockerfile multi-stage.
• Día 31–60: CI con caché, SAST/secret detection, versionado semántico + changelog, docker-compose local.
• Día 61–90: CD con releases etiquetadas, migraciones automatizadas, healthchecks, observabilidad (logs/metrics/traces) y rollback script.

---

Errores comunes (y cómo evitarlos)

• Comandos distintos por repositorio → Define un Makefile estándar.
• Variables de entorno sin validar → Esquemas con Zod o similares.
• Builds no reproducibles → Versiona lockfiles y usa contenedores.
• Secretos en el repo → Vault/Secrets Manager + detección en CI.
• Pipelines lentos → Cache, dependencias mínimas y jobs paralelos.

---

Checklist “Dev Ready”

• make setup y make test funcionan en una laptop nueva.
• Lint, formato y pruebas se ejecutan en cada PR.
• Imagen Docker multi-stage construye en CI.
• Versionado y changelog automatizados.
• Healthcheck y post-deploy script listos.
• Escaneo de secretos y dependencias habilitado.

Automatizar no es “nice to have”: es la base para entregar con calidad, previsibilidad y velocidad. Empieza pequeño (Makefile + pre-commit), añade CI y, cuando sea estable, activa CD con métricas y rollback.

Conoce WhatzMeAPI (API REST + Chatbot): WhatzMeApi