Sitio web • Documentación • X / Twitter • Slack de la comunidad • Foro

El Serverless Framework – Facilita el uso de AWS Lambda y otros servicios cloud gestionados para crear aplicaciones que escalan automáticamente, no cuestan nada cuando están inactivas y requieren un mantenimiento drásticamente reducido.

El Serverless Framework es una herramienta de línea de comandos con una sintaxis YAML accesible para desplegar tanto tu código como la infraestructura cloud necesaria para crear muchísimos casos de uso de aplicaciones serverless, como APIs, front-ends, canalizaciones de datos y tareas programadas. Es un framework multilenguaje que soporta Node.js, Typescript, Python, Go, Java y más. También es completamente extensible mediante más de 1.000 plugins que añaden más casos de uso y flujos de trabajo serverless al Framework.

Mantenido activamente por Serverless Inc.

Serverless Framework - V.4

Julio de 2026 – V.4 continúa incorporando actualizaciones importantes. Revísalas todas a continuación. Los lanzamientos recientes añadieron Sandboxes (computación efímera y aislada en AWS Lambda), soporte nativo para Amazon Bedrock AgentCore, Managed Instances, Durable Functions e inicio de sesión y SSO de AWS integrados. Como siempre, estamos más entusiasmados que nunca con el futuro serverless.

Novedades en V.4

Aquí tienes una lista de todo lo nuevo en V.4 hasta ahora:

Sandboxes – Despliega entornos de computación aislados y efímeros en AWS Lambda, ideales para cargas de trabajo no confiables o por sesión, como agentes de IA y ejecución de código. Más información aquí.
Soporte para Amazon Bedrock AgentCore – Define agentes de IA, memoria, herramientas, pasarelas, navegadores e intérpretes de código directamente en serverless.yml mediante la propiedad ai, y adminístralos con los comandos serverless agent. Más información aquí.
Inicio de sesión y SSO de AWS – Configura las credenciales de AWS mediante flujos basados en navegador con serverless login aws y serverless login aws sso.
Diffs de despliegue – Previsualiza cómo un despliegue cambiará tu stack en vivo de AWS CloudFormation antes de desplegar con serverless diff.
Comando Reconcile – Mantén los registros de uso sincronizados con tus cuentas de AWS cuando los stacks se eliminan fuera de la CLI, mediante serverless reconcile.
Instancias gestionadas – Soporte nativo para la ejecución de Lambda respaldada por EC2 que permite mayor rendimiento, capacidad predecible y cargas de trabajo de larga duración.
Funciones duraderas – Soporte integrado para flujos de trabajo duraderos con estado y orquestaciones de larga duración.
Modo de aislamiento de tenant en Lambda: Usa el modo de aislamiento de tenant para crear entornos de computación Lambda distintos por tenant, lo que ayuda a reducir los efectos de vecino ruidoso y aislar de forma más limpia a los clientes con alto tráfico.
Streaming de respuestas HTTP: Transmite en streaming registros, informes de larga duración, respuestas parciales o respuestas LLM de IA desde Lambda con las API HTTP de API Gateway.
Roles IAM por función: Añade políticas IAM por función o cambia todo el servicio para usar políticas por función.
Plugins integrados: Los plugins populares de la comunidad son ahora funciones integradas de primera clase del framework, incluidos Python requirements, AppSync, Prune, API Gateway Service Proxy y más.
Soporte mejorado para dominios personalizados: Ya no necesitas un plugin externo para configurar automáticamente dominios personalizados y certificados SSL para tus APIs y más. Ahora está integrado en la CLI de Serverless Framework.
Integración con Doppler: Ahora puedes obtener fácilmente secretos de Doppler mediante Variables de Serverless Framework.
Presentamos Serverless MCP: Diseñado para Cursor, Windsurf y otros IDE impulsados por IA, detecta automáticamente los recursos cloud de tu código, obteniendo registros, estado y configuración de AWS, lo que te permite depurar aplicaciones serverless directamente en tu IDE, ¡sin necesidad de visitar la consola de AWS! Soporta Serverless Framework, Cloudformation y más.
Soporte para AWS SAM, AWS CloudFormation y proyectos de Serverless Framework tradicionales: Ahora puedes usar una sola herramienta para desplegar los tres tipos de archivos de proyecto IaC. Más información aquí
Soporte nativo de TypeScript: Ahora puedes usar manejadores .ts en tus funciones de AWS Lambda en serverless.yml y hacer que se compilen automáticamente al desplegar. ESBuild ahora está incluido en el Framework, lo que hace posible esto. Más información aquí.
El AWS AI Stack: V.4 está optimizado para el AWS AI Stack. Despliega un boilerplate full-stack y serverless para aplicaciones de IA en AWS, con LLMs mediante Amazon Bedrock y mucho más.
Nuevo modo de desarrollo: Ejecuta serverless dev para que los eventos de tu arquitectura en producción se enruten a tu código local, lo que te permite hacer cambios rápidos sin desplegar. Más información aquí.
Soporte de los últimos runtimes: Soporte para Node.js 24 (nodejs24.x), Python 3.14 (python3.14) y Java 25 (java25) en AWS Lambda.
Soporte de las últimas regiones: Soporte para todas las regiones principales, incluida la recientemente anunciada ap-southeast-6 en Nueva Zelanda.
Nueva propiedad Stages: Organiza fácilmente la configuración específica de cada stage mediante stages y establece una configuración default de respaldo.
Experiencia de Compose mejorada: Serverless Compose ahora tiene una nueva y excelente experiencia de CLI que muestra mejor lo que se está desplegando.
Nuevas integraciones con Terraform y Vault: Obtén salidas de estado de varias soluciones de almacenamiento de estado de Terraform, y secretos de Vault. Documentación de Terraform Documentación de Vault
Comando de soporte: Envía solicitudes de soporte a nuestro equipo directamente desde la CLI, que incluyen automáticamente información contextual que puedes revisar antes de enviar.
Resumen de depuración para IA: Cuando te encuentres con un error, puedes ejecutar "serverless support --ai" para generar un informe conciso que detalle tu último error con todo el contexto necesario, optimizado para pegar en herramientas de IA como ChatGPT.
Controles avanzados de registro para AWS Lambda: Captura registros en JSON, mayor granularidad de registros y configuración de un grupo de registros personalizado. Aquí está el artículo de AWS. Aquí está la implementación en YAML
Integración con Axiom: Integra con la solución de observabilidad de Axiom para disfrutar de una potente experiencia de registros, métricas y trazas, a un coste 3 veces menor que AWS CloudWatch.
AWS SSO: Las variables de entorno, especialmente las establecidas por AWS SSO, tienen prioridad. El Framework y el Dashboard ya no interfieren con ellas.
Actualizaciones automáticas: Ahora ocurren por defecto. Aunque podrás controlar el nivel de actualizaciones que estás dispuesto a recibir.
Mejora de la incorporación y configuración: El comando serverless se ha reescrito para ser más útil al configurar un proyecto nuevo o existente.
Handlers de recursos personalizados actualizados: Todos los handlers de recursos personalizados usan ahora un runtime de Node.js actual (nodejs22.x).
Obsolescencia de proveedores que no son de AWS: Otros proveedores cloud han quedado obsoletos. V.4 se centra en ofrecer la mejor experiencia en AWS.

Cambios incompatibles

Buscamos evitar cambios incompatibles para el proveedor "aws". Sin embargo, hay algunas cosas importantes que están cambiando y de las que debes estar al tanto:

La licencia de V.4 está cambiando. Consulta la sección siguiente para obtener más información al respecto.
Se requiere autenticación dentro de la CLI.
Los proveedores que no son de AWS han quedado obsoletos. Presentaremos nuevas formas en V.4 de usar otros proveedores de infraestructura cloud.

Si te encuentras con cambios incompatibles adicionales, crea un issue. Para obtener más información sobre las diferencias y los posibles cambios incompatibles, consulta nuestra Documentación sobre la actualización a Serverless Framework V4.

Cambios de licencia en V.4

Ten en cuenta que la estructura y las licencias del repositorio de V.4 difieren de las del módulo npm de V.4. El módulo npm contiene software con licencia propietaria, ya que V.4 hace la transición a un producto SaaS común, como se anunció anteriormente. El código fuente original de Serverless Framework y más continuarán siendo software con licencia MIT, y el repositorio está estructurado para distinguir claramente entre componentes propietarios y de código abierto: el código con licencia MIT lleva su propio archivo LICENSE en packages/serverless, mientras que el LICENSE de la raíz del repositorio cubre los componentes propietarios.

Contenido

Características
Inicio rápido
Ejemplos
Plugins
Comunidad

Características

Construye más, gestiona menos: Innova más rápido dedicando menos tiempo a la gestión de infraestructura.
Máxima versatilidad: Aborda diversos casos de uso serverless, desde APIs y tareas programadas hasta web sockets y canalizaciones de datos.
Despliegue automatizado: Agiliza el desarrollo gestionando juntos el despliegue de código e infraestructura.
Desarrollo local: Enruta eventos de AWS a tu código local de AWS Lambda para desarrollar más rápido sin tener que desplegar cada cambio.
Facilidad de uso: Despliega aplicaciones complejas sin conocimientos profundos de infraestructura cloud, gracias a la sencilla configuración YAML.
Independiente del lenguaje: Desarrolla en tu lenguaje preferido: Node.js, Python, Java, Go, C#, Ruby, Swift, Kotlin, PHP, Scala o F#.
Gestión completa del ciclo de vida: Desarrolla, despliega, monitoriza, actualiza y soluciona problemas de aplicaciones serverless con facilidad.
Organización escalable: Estructura grandes proyectos y equipos de manera eficiente dividiendo aplicaciones grandes en Servicios para trabajar individualmente o en conjunto mediante Serverless Compose.
Entornos sin esfuerzo: Gestiona sin problemas los entornos de desarrollo, staging y producción.
Listo para personalizar: Extiende y modifica la funcionalidad del Framework con un rico ecosistema de plugins.
Comunidad vibrante: Obtén soporte y conéctate con una comunidad apasionada de desarrolladores de Serverless.

Inicio rápido

Así es como se instala el Serverless Framework, se configura un proyecto y se despliega en Amazon Web Services sobre infraestructura serverless como AWS Lambda, AWS DynamoDB, AWS S3 y más.

Instala el Serverless Framework mediante NPM

Primero, debes tener instalado el runtime de Node.js, versión 18.17.0 o superior; luego puedes instalar el Serverless Framework mediante NPM.

Abre tu CLI y ejecuta el siguiente comando para instalar el Serverless Framework globalmente.```text npm i serverless -g

Ejecuta `serverless` para verificar que tu instalación funciona y mostrar la versión actual.

<br/>

## Actualizar Serverless Framework

A partir de la versión 4, Serverless Framework se actualiza automáticamente y realiza una comprobación para ello cada 24 horas.

Puedes forzar una actualización ejecutando este comando:```text
serverless update

O bien, puedes establecer esta variable de entorno:```text SERVERLESS_FRAMEWORK_FORCE_UPDATE=true

<br/>

## El comando `serverless`

El Serverless Framework incluye un comando `serverless` que te guía a través del proceso de crear y desplegar un proyecto en AWS. Ayuda a descargar una plantilla, configurar las credenciales de AWS, configurar el panel del Serverless Framework, y más, mientras explica cada concepto en el camino.

Esta guía también te guiará para comenzar con el Serverless Framework, pero ten en cuenta que simplemente escribir el comando `serverless` puede ser la mejor experiencia.```text
serverless

Crear un Servicio

El concepto principal para un proyecto en Serverless Framework se conoce como un "Service", y se declara mediante un archivo serverless.yml, que contiene sintaxis simplificada para implementar infraestructura en la nube, como funciones de AWS Lambda, infraestructura que activa esas funciones con eventos, e infraestructura adicional que tus funciones de AWS Lambda puedan necesitar para diversos casos de uso (p. ej. tablas de bases de datos AWS DynamoDB, buckets de almacenamiento AWS S3, AWS API Gateways para recibir solicitudes HTTP y reenviarlas a AWS Lambda).

Un Service puede ser una aplicación completa, la lógica de un dominio específico (p. ej. "blog", "users", "products"), o un microservicio que maneja una tarea. Tú decides cómo organizar tu proyecto. En general, recomendamos comenzar con un enfoque monolítico para todo a fin de reducir la complejidad, hasta que dividir la lógica sea absolutamente necesario.

Para crear y configurar por completo un Service de Serverless Framework, usa el comando serverless, que ofrece un flujo de configuración interactivo.```text serverless

Esto te mostrará varias plantillas. Elige una que se adapte al idioma y al caso de uso que quieras.```text
Serverless ϟ Framework
Welcome to Serverless Framework V.4

Create a new project by selecting a Template to generate scaffolding for a specific use-case.

? Select A Template: …
❯ AWS / Node.js / HTTP API
  AWS / Node.js / Express API
  AWS / Node.js / Express API with DynamoDB
  AWS / Node.js / Scheduled Task
  AWS / Node.js / Simple Function
  AWS / Python / HTTP API
  AWS / Python / Flask API
  AWS / Python / Flask API with DynamoDB
  AWS / Python / Scheduled Task
  AWS / Python / Simple Function
  (Scroll for more)

Después de seleccionar una Plantilla de Servicio, sus archivos se descargarán y tendrás la oportunidad de darle un nombre a tu Servicio.```text ? Name Your Service: ›

Por favor, usa solo letras minúsculas, números y guiones. Además, mantén los nombres de los Services cortos, ya que se añaden al nombre de cada recurso en la nube que el Serverless Framework crea, y algunos recursos en la nube tienen restricciones de longitud de caracteres en sus nombres.

Obtén más información sobre Services y más en la [documentación de Conceptos básicos](https://www.serverless.com/framework/docs/providers/aws/guide/intro).

<br/>

## Iniciar sesión

A partir de Serverless Framework V.4, si usas el comando `serverless` para configurar un Service, eventualmente te pedirá que inicies sesión.

Si necesitas iniciar sesión fuera de ese flujo, ejecuta `serverless login`.

Al iniciar sesión, serás redirigido al [Panel de Serverless Framework](https://app.serverless.com) en tu navegador. Después de registrarte o iniciar sesión, vuelve a tu CLI y habrás iniciado sesión.

Ten en cuenta que puedes poner en marcha la CLI y el Panel de Serverless Framework de forma gratuita, y la CLI siempre será gratuita para organizaciones pequeñas e indiehackers. Para más información sobre precios, consulta nuestra [página de precios](https://serverless.com/pricing).

<br/>

## Crear una App

El concepto de "App" es un contenedor padre para uno o varios "Services" que puedes configurar opcionalmente mediante la propiedad `app` en tu `serverless.yml`. Configurar una `app` también habilita las funciones del Panel de Serverless Framework para ese Service, como el seguimiento de tus Services y sus despliegues en el Panel de Serverless Framework, la posibilidad de compartir salidas entre ellos, compartir secretos entre ellos y habilitar métricas, trazas y registros.

Si usas el comando de incorporación `serverless`, te ayudará a configurar una `app` y añadirla a tu Service. También puedes usar el comando `serverless` para crear una App en un Service existente, o crear una App en el Panel.```text
❯ Create A New App
  ecommerce
  blog
  acmeinc
  Skip Adding An App

La aplicación también puede configurarse manualmente en serverless.yml mediante la propiedad app:```yaml service: my-service app: my-app

Si no quieres usar las funciones del Dashboard de Serverless Framework, simplemente no agregues una propiedad `app`. Las apps no son obligatorias.

<br/>

## Configuración de credenciales de AWS

Para implementar infraestructura en la nube en AWS, debes darle al Serverless Framework acceso a tus credenciales de AWS.

Ejecutar el comando `serverless` de Serverless Framework en un Service nuevo o existente ayudará a identificar si las credenciales de AWS se han configurado correctamente o si han caducado, o te ayudará a configurarlas desde cero.```text
No valid AWS Credentials were found in your environment variables or on your machine. Serverless Framework needs these to access your AWS account and deploy resources to it. Choose an option below to set up AWS Credentials.

❯ Create AWS IAM Role (Easy & Recommended)
  Save AWS Credentials in a Local Profile
  Skip & Set Later (AWS SSO, ENV Vars)

Recomendamos crear un Rol de IAM de AWS que esté almacenado en el Panel de Serverless Framework. Pronto admitiremos muchas Credenciales de Proveedor, y el Panel es un excelente lugar para mantenerlas centralizadas en todo tu equipo, ayudándote a mantenerte organizado y eliminando de forma segura la necesidad de guardar credenciales en las máquinas de tus compañeros.

Si estás usando AWS SSO, puedes ejecutar serverless login aws sso para iniciar sesión a través de tu navegador, o simplemente pegar tus credenciales SSO temporales en el terminal como variables de entorno.

Para obtener más información sobre cómo configurar tus Credenciales de AWS, lee esta guía.

Desplegar un Servicio

Después de usar el comando serverless para configurar todo, es hora de desplegar tu Servicio en AWS.

Asegúrate de que tu sesión de terminal esté dentro del directorio que contiene tu archivo serverless.yml. Si acabas de crear un Servicio, no olvides hacer cd hacia él.```text cd [your-new-service-name]

El despliegue creará/actualizará la infraestructura y el código en la nube de AWS, todo al mismo tiempo.

Ejecuta el comando `deploy`:```text
serverless deploy

Se pueden encontrar más detalles sobre el despliegue aquí.

Desarrollo

Muchos desarrolladores de Serverless Framework y de serverless generalmente eligen desarrollar en la nube, ya que esto coincide con la realidad (es decir, tu entorno de producción), y emular Lambda y otras dependencias de infraestructura localmente puede ser complejo.

En Serverless Framework V.4, hemos creado un enfoque híbrido de desarrollo, para ayudar a los desarrolladores a desarrollar rápidamente con la precisión del entorno real de la nube. Este es el nuevo comando dev:```text serverless dev

Cuando ejecutas este comando, sucede lo siguiente...

Se llevará a cabo una implementación de AWS Cloudformation para modificar ligeramente todas las funciones de AWS Lambda dentro de tu Service para que incluyan un envoltorio ligero.

Una vez que esta implementación de AWS Cloudformation haya finalizado, tus funciones de AWS Lambda activas dentro de tu Service seguirán pudiendo recibir eventos y ser invocadas dentro de AWS.

Sin embargo, los eventos se enviarán de forma segura e instantánea a tu máquina, y se ejecutará el código de tu máquina, en lugar del código dentro de tus funciones de AWS Lambda activas.

Esto te permite realizar cambios en tu código sin tener que desplegar o recrear localmente todos los aspectos de tu arquitectura, lo que te permite desarrollar con rapidez.

Los registros de tu código local también se mostrarán dentro de tu sesión `dev` en la terminal.

Una vez que tu código haya terminado, la respuesta de tu código local se reenviará a tus funciones de AWS Lambda activas, y ellas devolverán la respuesta, igual que lo haría una función de AWS Lambda normal en la nube.

Ten en cuenta que `dev` solo está diseñado para etapas/entornos de desarrollo o personales y no debe ejecutarse en producción ni en ninguna etapa donde se procese un gran volumen de eventos.

Una vez que hayas terminado con tu sesión `dev`, DEBES volver a desplegar, usando `serverless deploy`, para enviar tus cambios locales recientes de vuelta a tus funciones de AWS Lambda activas; de lo contrario, tus funciones de AWS Lambda fallarán(!)

Puedes encontrar más detalles sobre el modo dev [aquí](https://www.serverless.com/framework/docs/providers/aws/cli-reference/dev).

<br/>

## Invocación

Para invocar tu función de AWS Lambda en la nube, puedes encontrar las URL de tus funciones con puntos de enlace de API en la salida de `serverless deploy`, u obtenerlas mediante `serverless info`. Si tus funciones no tienen puntos de enlace de API, puedes usar el comando `invoke`, de la siguiente manera:```bash
sls invoke -f hello

# Invoke and display logs:
serverless invoke -f hello --log

Puedes encontrar más detalles sobre el comando invoke aquí.

Desplegar Funciones

Para desplegar cambios de código rápidamente, puedes omitir el comando serverless deploy, que es mucho más lento ya que activa una actualización completa de AWS CloudFormation, y desplegar solo los cambios de código y configuración en una función específica de AWS Lambda.

Para desplegar cambios de código y configuración en funciones individuales de AWS Lambda en segundos, usa el comando deploy function, con -f [function name in serverless.yml] asignado a la función que deseas desplegar.```text serverless deploy function -f my-api

Puedes encontrar más detalles sobre el comando `deploy function` [aquí](https://www.serverless.com/framework/docs/providers/aws/cli-reference/deploy-function).

<br/>

## Transmisión de registros

Puedes usar Serverless Framework para transmitir registros desde AWS Cloudwatch directamente a tu terminal. Usa el comando `sls logs` en una ventana de terminal separada:```bash
sls logs -f [Function name in serverless.yml] -t

Selecciona una función específica mediante la opción -f y habilita el seguimiento (es decir, streaming) mediante la opción -t.

Desarrollo Local Completo

Muchos usuarios de Serverless Framework optan por emular toda su arquitectura serverless localmente. Ten en cuenta que emular AWS Lambda y otros servicios en la nube nunca es preciso y el proceso puede ser complejo, especialmente a medida que tu proyecto y tus compañeros de equipo crecen. A partir de V.4, recomendamos encarecidamente usar el nuevo modo dev con etapas personales.

Si decides desarrollar localmente, te recomendamos el siguiente flujo de trabajo...

Usa el comando invoke local para invocar tu función localmente:```bash sls invoke local -f my-api

También puedes pasar datos a esta invocación local de varias formas. Aquí tienes una de ellas:```bash
sls invoke local --function functionName --data '{"a":"bar"}'

Más detalles sobre el comando invoke local se pueden encontrar aquí

Serverless Framework también tiene un gran plugin que te permite ejecutar un servidor localmente y emular AWS API Gateway. Este es el plugin serverless-offline.

Se pueden encontrar más detalles en la documentación de serverless-offline.

Usar Plugins

Un gran beneficio de Serverless Framework reside en su ecosistema de plugins.

Los plugins extienden o sobrescriben Serverless Framework, otorgándole nuevos casos de uso o capacidades, y hay cientos de ellos.

Ten en cuenta que algunos plugins que antes eran populares ya no son necesarios — su funcionalidad ahora está integrada en el framework, incluyendo requisitos de Python, dominios personalizados, AppSync, Prune y API Gateway Service Proxy.

Algunos de los plugins más comunes son:

Serverless Offline - Emula AWS Lambda y API Gateway localmente al desarrollar tu proyecto Serverless.
Serverless Step Functions - Construye arquitecturas de AWS Step Functions.

Puedes añadir un plugin a tu servicio con serverless plugin install --name pluginName, que lo instala vía npm y lo registra en tu serverless.yml.

Componer Servicios

Serverless Framework Compose te permite trabajar con múltiples servicios de Serverless Framework a la vez, y hacer lo siguiente...

Desplegar múltiples servicios en paralelo
Desplegar servicios en un orden específico
Compartir salidas de un servicio a otro
Ejecutar comandos en múltiples servicios

Así es como podría verse una estructura de proyecto:```bash my-app/ service-a/ src/ ... serverless.yml service-b/ src/ ... serverless.yml

El uso de Serverless Framework Compose requiere un archivo `serverless-compose.yml`. En él, se especifican qué Servicios se desean implementar. También se pueden compartir datos de un Servicio a otro, lo que también crea un orden de implementación.```yaml
# serverless-compose.yml

services:
  service-a:
    path: service-a

  service-b:
    path: service-b
    params:
      queueUrl: ${service-a.queueUrl}

Los Outputs que deben ser heredados por otro Servicio se definen típicamente como Outputs de AWS CloudFormation:```yaml

service-a/serverless.yml

...

resources: Resources: MyQueue: Type: AWS::SQS::Queue # ... Outputs: queueUrl: Value: !Ref MyQueue

El valor se pasará a `service-b` [como parámetro](https://www.serverless.com/framework/docs/guides/parameters) denominado `queueUrl`. Los parámetros se pueden referenciar en la configuración de Serverless Framework mediante la sintaxis `${param:xxx}`:```yaml
# service-b/serverless.yml

provider:
  ...
  environment:
    # Here we inject the queue URL as a Lambda environment variable
    SERVICE_A_QUEUE_URL: ${param:queueUrl}

Se pueden encontrar más detalles sobre Serverless Framework Compose aquí.

Comando de soporte

En Serverless Framework V.4, hemos introducido el comando serverless support, una funcionalidad destacada que te permite generar informes de incidencias o conectarte directamente con nuestro equipo de soporte. Incluye automáticamente el contexto relevante y omite detalles sensibles como secretos e información de cuenta, que puedes revisar antes de enviarlos. Este proceso optimizado garantiza que tus incidencias se resuelvan de forma rápida y segura.

Para usar esta funcionalidad, después de un error o de cualquier comando, ejecuta:```bash sls support

Después de cada comando, tanto si tiene éxito como si no, el contexto se guarda dentro de tu directorio de trabajo actual en la carpeta `.serverless`.

Para abrir un nuevo ticket de soporte, ejecuta el comando `sls support` y selecciona `Get priority support...`. Opcionalmente, podrás revisar y editar el informe generado. La apertura de tickets de soporte solo está disponible para los usuarios que se suscriban a una Suscripción.

También puedes generar informes sin enviar un nuevo ticket de soporte. Esto es útil para compartir el contexto con otras personas, abrir issues en Github o usarlo con un prompt de IA como ChatGPT. Para ello, ejecuta el comando `sls support` y selecciona `Create a summary report...` o `Create a comprehensive report..`. Puedes omitir el prompt ejecutando `sls support --summary` o `sls support --all`. Esto es especialmente útil para capturar el informe en el portapapeles (p. ej., `sls support --summary | pbcopy`).

<br/>

## Elimina tu servicio

Si quieres eliminar tu servicio, ejecuta `remove`. Esto eliminará todos los recursos de AWS creados por tu proyecto y garantizará que no incurras en cargos inesperados. También eliminará el servicio de Serverless Dashboard.```bash
sls remove

Más detalles sobre el comando remove se pueden encontrar aquí.

Lo que sigue

Aquí hay algunos recursos útiles para continuar con el Serverless Framework:

Comunidad

Seguridad y divulgación de errores

Nos tomamos la seguridad muy en serio. Si descubres un problema de seguridad, divúlgalo de forma responsable poniéndote en contacto con nosotros en [email protected]. Por favor, no reveles públicamente vulnerabilidades hasta que las hayamos abordado.

Para más detalles, consulta nuestra Política de seguridad.

serverless [email protected]

Categorías