¿Qué es una API y cómo uso Lambda?

¿Qué es una API y cómo la conecto con Lambda?
Una guía para los que recién están entrando al mundo del backend y no quieren leer documentación de 40 páginas.

¿Qué es una API?
Mira, una API no es nada del otro mundo. Es simplemente la forma en que dos programas se comunican. Uno pregunta, el otro responde. Eso es todo.

🇪🇨 Piensa en mandar una razón con alguien del barrio. Tú no vas personalmente donde tu tía a pedirle que te mande la olla de seco — mandas al chico de la tienda con el recado. Él lleva el mensaje, trae la olla, y listo. Tú nunca supiste por dónde fue ni cómo lo hizo. Una API funciona igual: es ese mensajero que va, pregunta, y trae lo que necesitas.

Cuando abres una app del clima, esa app no tiene los datos del tiempo guardados en tu celular. Le pregunta a un servidor externo a través de una API, y ese servidor le responde con la información. Todo eso pasa en milisegundos y tú nunca lo ves.
Las APIs que vamos a usar aquí son REST APIs. Básicamente funcionan sobre internet, se comunican con verbos simples (GET, POST, PUT, DELETE) y responden en JSON, que es un formato de texto fácil de leer tanto para humanos como para máquinas.

Los verbos HTTP: cómo le dices a la API qué quieres
Cada vez que haces una petición a una API, usas un verbo que indica la intención. Son cuatro y tienen mucho sentido:
VerboQué haceEjemplo realGETTrae informaciónVer la lista de usuariosPOSTCrea algo nuevoRegistrar un usuarioPUTModifica algo que ya existeCambiar el nombre de un usuarioDELETEBorra algoEliminar una cuenta
La URL que apuntas se llama endpoint. Por ejemplo /usuarios es un endpoint. El verbo le dice qué hacer con ese recurso.

¿Qué es AWS Lambda?
Aquí está la parte que más me gusta explicar porque cuando la entiendes, cambia cómo ves el desarrollo.
Normalmente para tener código corriendo en internet necesitas un servidor. Una máquina prendida todo el día esperando peticiones, aunque nadie las haga. Eso cuesta plata y alguien tiene que mantenerlo.
Lambda cambia eso completamente. Tú escribes tu función, la subes a AWS, y te olvidas del servidor. Lambda la mantiene dormida hasta que llegue una petición. Cuando llega, despierta, corre tu código, responde, y vuelve a dormir. Pagas solo por los milisegundos que estuvo activa.
Una función Lambda luce así:

handler = async (event) => {

  // 'event' tiene todo lo que llegó en la petición
  const nombre = event.queryStringParameters?.nombre;

  return {
    statusCode: 200,
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ mensaje: `Hola, ${nombre}!` })
  };
};

Sin configurar puertos. Sin instalar nada. Solo la lógica que importa.

¿Y para qué API Gateway?

Lambda sola no tiene una URL pública. Nadie puede llegar a ella desde internet directamente. API Gateway es lo que le da esa puerta de entrada.

Tú defines las rutas, los métodos que acepta cada una, y a qué función Lambda apuntan. Así de simple:

GET    /usuarios         → función que lista usuarios
GET    /usuarios/{id}    → función que trae uno
POST   /usuarios         → función que crea uno
PUT    /usuarios/{id}    → función que lo actualiza
DELETE /usuarios/{id}    → función que lo borra

Código real: CRUD sin base de datos
Para no complicar todo desde el inicio, vamos a guardar los datos en memoria dentro de Lambda. No persisten para siempre, pero sirven perfecto para probar que todo funciona antes de conectar una base de datos real.

usuarios = [
  { id: '1', nombre: 'Ana', email: '[e-mail]' },
  { id: '2', nombre: 'Luis', email: '[e-mail]' },
];
let nextId = 3;

exports.handler = async (event) => {
  const metodo = event.httpMethod;
  const id     = event.pathParameters?.id;
  const body   = JSON.parse(event.body || '{}');

  if (metodo === 'GET'    && !id)  return listar();
  if (metodo === 'GET'    &&  id)  return obtener(id);
  if (metodo === 'POST')           return crear(body);
  if (metodo === 'PUT'    &&  id)  return actualizar(id, body);
  if (metodo === 'DELETE' &&  id)  return eliminar(id);

  return responder(405, { error: 'Método no permitido' });
};

function listar() {
  return responder(200, usuarios);
}

function obtener(id) {
  const u = usuarios.find(x => x.id === id);
  return u ? responder(200, u) : responder(404, { error: 'No encontrado' });
}

function crear(body) {
  if (!body.nombre || !body.email)
    return responder(400, { error: 'Faltan nombre y email' });
  const nuevo = { id: String(nextId++), ...body };
  usuarios.push(nuevo);
  return responder(201, nuevo);
}

function actualizar(id, body) {
  const i = usuarios.findIndex(x => x.id === id);
  if (i === -1) return responder(404, { error: 'No encontrado' });
  usuarios[i] = { ...usuarios[i], ...body, id };
  return responder(200, usuarios[i]);
}

function eliminar(id) {
  const antes = usuarios.length;
  usuarios = usuarios.filter(x => x.id !== id);
  return usuarios.length < antes
    ? responder(200, { ok: `Usuario ${id} eliminado` })
    : responder(404, { error: 'No encontrado' });
}

function responder(statusCode, datos) {
  return {
    statusCode,
    headers: {
      'Content-Type': 'application/json',
      'Access-Control-Allow-Origin': '*'
    },
    body: JSON.stringify(datos)
  };
}

Subirlo a AWS en 5 pasos

1. Crear la función Lambda AWS Console → Lambda → Crear función. Nombre: api-usuarios, runtime: Node.js 20.x.
2. Pegar el código y hacer Deploy Copia el código en el editor en línea, clic en Deploy. Listo.
3. Crear el API Gateway API Gateway → Crear API → HTTP API. Conectas tu Lambda como integración.
4. Definir las rutas Agregas las cinco rutas de arriba. Todas apuntan a la misma función.
5. Probar Te dan una URL tipo https://abc123.execute-api.us-east-1.amazonaws.com/dev. La pegas en Postman y empiezas a hacer peticiones.

Para Terminar
Con esto ya tienes una API funcionando en la nube, sin servidor propio, sin base de datos, y sin gastar nada relevante. El siguiente paso cuando estés cómodo con esto es reemplazar el array en memoria por DynamoDB, que es la base de datos serverless de AWS. La estructura del código no cambia mucho, solo agregas las llamadas al SDK.
Pero eso para el siguiente post xD