AWS Amplify Gen 2 — Cap.1: ¿Qué es AWS Amplify Gen 2?

El Problema que Amplify Resuelve

Los desarrolladores frontend son extraordinariamente productivos en JavaScript y TypeScript. Pueden lanzar una interfaz Next.js pulida en días. Pero en el momento en que necesitan un backend — autenticación, una base de datos, carga de archivos, lógica serverless — chocan contra una pared de complejidad de AWS. Roles IAM, sintaxis de CloudFormation, configuración de VPC, diseño de partition keys en DynamoDB: estas son disciplinas completas en sí mismas.

AWS Amplify fue creado específicamente para cerrar esta brecha. La promesa central: un desarrollador frontend con habilidades en TypeScript debería poder configurar un backend AWS de nivel de producción sin convertirse en un especialista de AWS.

Gen 1 (lanzado en 2018) abordó esto con un CLI interactivo. Ejecutabas amplify add auth, respondías una serie de preguntas en la terminal, y Amplify generaba una plantilla de CloudFormation detrás de escena. Funcionaba, pero tenía una falla fundamental: tu infraestructura vivía en archivos JSON auto-generados que eran difíciles de revisar en pull requests, imposibles de razonar, y dolorosos de personalizar más allá de lo que el wizard ofrecía.

Gen 2 (disponible generalmente desde mayo de 2024) tomó un enfoque completamente diferente. En lugar de prompts, escribes TypeScript. Tu backend es un conjunto de archivos .ts que mantienes, revisas y versionas como cualquier otro código. Este cambio — de archivos de configuración a código — es la característica definitoria de Amplify Gen 2.

// amplify/backend.ts — este ES tu backend
import { defineBackend } from '@aws-amplify/backend';
import { auth } from './auth/resource';
import { data } from './data/resource';

defineBackend({
  auth,
  data,
});

Eso es una definición completa de backend. Tres imports, una llamada a función. Bajo el capó, provisiona Cognito, AppSync, DynamoDB, roles IAM, y toda la conexión entre ellos.

Los Cuatro Servicios Core

Amplify Gen 2 es una selección opinada de servicios AWS, cada uno mapeado a una preocupación común de backend:

Auth mapea a Amazon Cognito — la plataforma de identidad gestionada de AWS. Cognito maneja el registro de usuarios, login, providers sociales (Google, GitHub, Apple), MFA, y emisión de tokens JWT. Lo configuras a través de defineAuth().

Data mapea a AWS AppSync (API GraphQL gestionada) respaldada por Amazon DynamoDB (base de datos NoSQL). Cuando defines un modelo de datos en TypeScript, Amplify crea un schema GraphQL en AppSync y una tabla DynamoDB con índices apropiados. Interactúas con los datos a través de un cliente completamente tipado generado desde tu schema.

Storage mapea a Amazon S3. Amplify agrega un modelo de permisos basado en rutas sobre S3, para que puedas decir fácilmente “los usuarios solo pueden leer/escribir sus propios archivos” sin escribir políticas de bucket complejas.

Functions mapea a AWS Lambda. Las funciones serverless pueden dispararse en un schedule, en respuesta a eventos de S3, como triggers de Cognito, o exponerse como endpoints HTTP vía API Gateway.

// amplify/auth/resource.ts
import { defineAuth } from '@aws-amplify/backend';

export const auth = defineAuth({
  loginWith: {
    email: true, // Habilita registro/login con email y contraseña → crea Cognito User Pool
  },
});

// amplify/data/resource.ts
import { a, defineData, type ClientSchema } from '@aws-amplify/backend';

const schema = a.schema({
  Post: a.model({
    title: a.string().required(),   // Campo obligatorio
    content: a.string(),            // Campo opcional (nullable por defecto)
    published: a.boolean().default(false), // Booleano con valor por defecto
  }).authorization(allow => [allow.owner()]), // Solo el creador puede leer/escribir sus posts
});

export type Schema = ClientSchema<typeof schema>; // Genera tipos TS del schema para el frontend

export const data = defineData({
  schema,
  authorizationModes: {
    defaultAuthorizationMode: 'userPool', // Usa tokens JWT de Cognito para autorizar queries
  },
});

CDK Bajo el Capó

Una de las decisiones arquitectónicas más importantes en Gen 2 es que compila a AWS CDK (Cloud Development Kit). CDK es el framework de infraestructura como código de AWS que te permite definir recursos en la nube en TypeScript (o Python, Java, Go, etc.) y sintetizarlos a CloudFormation.

Amplify Gen 2 usa CDK L3 Constructs — el nivel más alto de abstracción. Mientras que un construct L1 mapea 1:1 a un recurso de CloudFormation (verboso y de bajo nivel), y un construct L2 envuelve un solo servicio con valores predeterminados sensatos, un construct L3 encapsula un patrón completo a través de múltiples servicios.

defineAuth() es un construct L3. Internamente, crea: un User Pool de Cognito, un User Pool Client de Cognito, un Identity Pool de Cognito, roles IAM para usuarios autenticados y no autenticados, y toda la conexión entre ellos. Lo que serían 200+ líneas de YAML de CloudFormation se convierte en una llamada a función en TypeScript.

Esta arquitectura importa por dos razones. Primero, no estás bloqueado en las abstracciones de Amplify — siempre puedes hacer import { Stack } from 'aws-cdk-lib' y agregar cualquier servicio AWS que Amplify no soporte nativamente. Segundo, todo lo que hace Amplify es inspectable: puedes ejecutar npx ampx generate para ver el CloudFormation generado y entender exactamente qué se está desplegando.

flowchart LR
  A["Archivos TypeScript
(amplify/)"] -->|compilar| B["CDK Constructs"]
  B -->|sintetizar| C["Plantilla
CloudFormation"]
  C -->|desplegar| D["Recursos AWS
(Cognito, AppSync,
DynamoDB, S3)"]
  D -->|generar| E["amplifyconfiguration.json
(config del frontend)"]
  style A fill:#f0f4ff,stroke:#4f46e5
  style D fill:#fff7ed,stroke:#ea580c
  style E fill:#f0fdf4,stroke:#16a34a

Amplify vs las Alternativas

Entender cuándo elegir Amplify requiere conocer sus trade-offs frente a las alternativas:

Firebase / Supabase: Estas son plataformas BaaS (Backend as a Service) con sus propias bases de datos y APIs propietarias. Amplify difiere en que se despliega en tu propia cuenta AWS — tú posees los datos, pagas a AWS directamente, y tienes acceso completo a los recursos subyacentes. El trade-off es más complejidad durante la configuración, pero significativamente más control y sin vendor lock-in más allá de AWS mismo.

Vercel + PlanetScale/Neon: Esta combinación ofrece excelente experiencia de desarrollador para Next.js pero requiere unir múltiples vendors. Amplify mantiene todo en un ecosistema (AWS) y se integra profundamente con Next.js App Router incluyendo server-side rendering vía Lambda@Edge.

CDK puro: CDK te da más control pero requiere profunda experiencia en AWS. El sweet spot de Amplify es precisamente equipos que quieren infraestructura AWS sin necesitar un ingeniero DevOps dedicado.

Elige Amplify cuando: tu equipo conoce TypeScript, quieres infraestructura AWS, necesitas Auth + Data + Storage sin experiencia extensa en AWS, y estás construyendo un proyecto nuevo. Considera alternativas cuando: necesitas datos relacionales con joins complejos (usa RDS en lugar de DynamoDB), tu equipo tiene ingenieros dedicados de AWS/infraestructura (CDK puro da más control), o necesitas una base de datos distribuida globalmente en el edge.

Configurando tu Entorno

Antes de escribir cualquier código, instala los prerequisitos:

# Node.js 18 o posterior (verifica con node --version)
node --version

# Instala el Amplify backend CLI globalmente
npm install -g @aws-amplify/backend-cli

# Verifica la instalación
ampx --version

# Configura las credenciales AWS (necesitas una cuenta AWS)
# Opción 1: AWS CLI
aws configure

# Opción 2: Variables de entorno
export AWS_ACCESS_KEY_ID=tu-key-id
export AWS_SECRET_ACCESS_KEY=tu-secret-key
export AWS_REGION=us-east-1

La cuenta AWS requiere un usuario IAM (o IAM Identity Center SSO) con AdministratorAccess durante el desarrollo. En producción, reducirás los permisos, pero para el desarrollo del sandbox local, los permisos amplios reducen la fricción.

Pon a Prueba tu Conocimiento