Parte VII: Apéndices

# macOS
brew install git

# Ubuntu/Debian
sudo apt install git -y

# Windows (WSL)
wsl --install
# dentro de WSL: sudo apt install git -y

git config --global user.name "Tu nombre"
git config --global user.email "tu@email.com"
git config --global init.defaultBranch main
git config --global pull.rebase true

# Clonar
git clone https://github.com/sazon-foods/backstage-sazon.git
cd backstage-sazon

# Crear rama
git checkout -b feat/sazon-status-plugin

# Editar archivos, luego:
git add .
git commit -m "feat(sazon-status): add /health endpoint"

# Sincronizar y pushear
git pull --rebase
git push origin feat/sazon-status-plugin

# Abrir PR desde la URL que imprime GitHub CLI:
gh pr create --fill

git status                # qué ha cambiado
git diff                  # diff sin stage
git diff --staged         # diff en stage
git log --oneline -10     # últimos 10 commits
git stash                 # guarda cambios sin commitear
git stash pop             # los restaura
git reset --hard HEAD~1   # descarta el último commit (cuidado)
git revert HEAD            # revierte el último commit (seguro)

pwd                       # dónde estoy
ls                        # qué hay aquí
ls -la                    # con ocultos y detalles
cd /ruta                  # cambiar de directorio
cd -                      # volver al directorio anterior
cd ~                      # ir al home

mkdir -p dir/sub          # crear estructura
touch file.txt            # crear/actualizar archivo
cp a.txt b.txt            # copiar
mv a.txt dir/             # mover
rm file.txt               # borrar
rm -rf dir                # borrar recursivo (cuidado)
cat file.txt              # imprimir
less file.txt             # paginar
head -20 file.txt         # primeras 20 líneas
tail -f file.txt          # últimas líneas, sigue creciendo

ls | grep .yaml           # filtrar
cat file | sort | uniq    # encadenar
echo "hola" > file.txt    # sobreescribir
echo "adicional" >> file.txt  # añadir
cmd 2>&1                  # stderr a stdout
cmd > out.log 2>&1        # todo a un archivo

ps aux | grep node        # procesos de node
kill PID                  # terminar proceso (SIGTERM)
kill -9 PID               # forzar (SIGKILL)
nohup cmd &               # correr en background, inmune a hangup
jobs                      # trabajos del shell actual
fg %1                     # traer a foreground

chmod +x script.sh        # hacer ejecutable
chmod 644 file            # rw-r--r--
chmod 600 key.pem         # rw------- (privado)
chown user:group file     # cambiar dueño

ssh-keygen -t ed25519 -C "tu@email.com"   # crear clave
ssh-copy-id user@host                     # subir pública
ssh user@host                             # conectar

docker pull postgres:16           # bajar imagen
docker images                     # listar imágenes
docker run -d --name db postgres:16
docker ps                         # contenedores corriendo
docker ps -a                      # todos
docker logs -f db                 # logs del contenedor
docker exec -it db bash           # shell interactivo
docker stop db                    # parar
docker rm db                      # borrar
docker rmi postgres:16            # borrar imagen

services:
  db:
    image: postgres:16
    environment:
      POSTGRES_PASSWORD: secret
    volumes:
      - pgdata:/var/lib/postgresql/data
volumes:
  pgdata:

docker compose up -d      # arranca en background
docker compose down       # para y borra contenedores (no volúmenes)
docker compose logs -f    # logs agregados
docker compose exec db bash

FROM node:20-bookworm-slim AS builder
WORKDIR /app
COPY package.json pnpm-lock.yaml ./
RUN corepack enable && pnpm install --frozen-lockfile
COPY . .
RUN pnpm build

FROM node:20-bookworm-slim
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
EXPOSE 7007
CMD ["node", "dist/index.js"]

kubectl get pods -A
kubectl get svc,ing -A
kubectl describe pod <name>
kubectl logs -f <pod>
kubectl exec -it <pod> -- bash
kubectl apply -f deployment.yaml
kubectl delete -f deployment.yaml
kubectl rollout status deployment/backstage
kubectl rollout undo deployment/backstage    # rollback
kubectl top pod                                # uso de recursos

apiVersion: apps/v1
kind: Deployment
metadata:
  name: backstage
  namespace: backstage
spec:
  replicas: 2
  selector:
    matchLabels: { app: backstage }
  template:
    metadata:
      labels: { app: backstage }
    spec:
      containers:
        - name: backstage
          image: ghcr.io/sazon-foods/backstage:1.31.0
          ports: [{ containerPort: 7007 }]
          envFrom:
            - secretRef: { name: backstage-secrets }

apiVersion: v1
kind: Service
metadata: { name: backstage, namespace: backstage }
spec:
  selector: { app: backstage }
  ports: [{ port: 80, targetPort: 7007 }]
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata: { name: backstage, namespace: backstage }
spec:
  rules:
    - host: backstage.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: backstage
                port: { number: 80 }

cadena: "hola"
numero: 42
boolean: true
nulo: null
fecha: 2026-07-23
lista:
  - uno
  - dos
  - tres
mapa:
  clave1: valor1
  clave2: valor2
multilinea: |
  Línea 1
  Línea 2

{
  "cadena": "hola",
  "numero": 42,
  "boolean": true,
  "lista": ["uno", "dos"],
  "mapa": { "clave1": "valor1" }
}

apiVersion: v1
kind: Service
metadata: { name: a }
spec: { selector: { app: a } }
---
apiVersion: v1
kind: Service
metadata: { name: b }
spec: { selector: { app: b } }

defaults: &defaults
  retries: 3
  timeout: 30
service-a:
  <<: *defaults
  name: a
service-b:
  <<: *defaults
  name: b

const name: string = 'sazon';
const port: number = 7007;
const enabled: boolean = true;
const tags: string[] = ['api', 'restaurant'];
const map: Record<string, number> = { a: 1 };
const maybe: string | null = null;

function add(a: number, b: number): number { return a + b; }
const greet = (name: string): string => `Hola, ${name}`;
const optional = (x?: number) => x ?? 0;     // nullish coalescing
async function load(): Promise<string> { return 'ok'; }

interface Service { name: string; port: number; tags?: string[]; }
const svc: Service = { name: 'api', port: 7007 };
const withDefaults: Service = { name: 'api', port: 7007, tags: [] };

async function getStatus(service: string) {
  const res = await fetch(`/api/sazon/status/${service}`);
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return res.json() as Promise<{ status: string }>;
}

const { name, port = 80 } = svc;
const [first, ...rest] = ['a', 'b', 'c']; // first='a', rest=['b','c']

import { z } from 'zod';
import type { LoggerService } from '@backstage/backend-plugin-api';

export const StatusSchema = z.object({ service: z.string() });
export type Status = z.infer<typeof StatusSchema>;

{
  "name": "@sazon/plugin-x",
  "version": "0.1.0",
  "main": "src/index.ts",
  "scripts": {
    "start": "backstage-cli package start",
    "test": "backstage-cli package test"
  }
}

{
  "sub": "user:default/tester",
  "email": "tester@sazon-foods.com",
  "preferred_username": "tester",
  "name": "Maite Tester",
  "groups": ["platform-sazon", "engineering"],
  "iss": "https://keycloak.sazon-foods.com/realms/sazon",
  "aud": "backstage",
  "exp": 1720003200
}

// Antes (legacy)
const backend = new Backend({ ... });
backend.add(...);
// muchas líneas de routers
backend.start();

// Después (New Backend System)
const backend = createBackend();
backend.add(import('@backstage/plugin-catalog-backend'));
backend.add(import('@sazon/plugin-sazon-status-backend'));
backend.start();

// Antes (legacy)
export default async function createPlugin({ ... }: PluginEnvironment) {
  const router = Router();
  router.get('/foo', ...);
  return router;
}

// Después (New Backend System)
export const fooPlugin = createBackendPlugin({
  id: 'foo',
  register(env) {
    env.registerInit({
      deps: { httpRouter: coreServices.httpRouter },
      async init({ httpRouter }) {
        httpRouter.use(await createRouter({ ... }));
      },
    });
  },
});

env.registerInit({
  deps: {
    database: coreServices.database,
    logger: coreServices.logger,
    httpAuth: coreServices.httpAuth,
  },
  async init({ database, logger, httpAuth }) { ... },
});

export const myCustomService = createServiceFactory({
  service: createServiceRef<MyService>({ id: 'my-custom', scope: 'plugin' }),
  factory: async () => MyServiceImpl,
});