kotless

Sin kot

Kotless significa Kotlin Serverless Framework.

Su enfoque radica en reducir la rutina de la creación de implementación sin servidor al generarla directamente del código de la aplicación en sí.

Entonces, simplemente hablando, Kotless le brinda un botón mágico para implementar su aplicación web como una aplicación sin servidor en AWS y Azure.

Kotless consta de dos partes principales:

• DSL proporciona una forma de definir aplicaciones sin servidor. Hay tres DSL compatibles:
  • Kotless DSL - Kotless propio DSL que proporciona anotaciones para declarar enrutamiento, eventos programados, etc.
  • KTOR - Motor Ktor que está introspectado por Kotless. Use la sintaxis de KTOR estándar y Kotless generará implementación.
  • Boot de primavera : contenedor Spring Boot Servidor que es introspectado por Kotless. Use la sintaxis estándar de Spring y Kotless generará implementación.
• El complemento Kotless Gradle proporciona una forma de implementar la aplicación sin servidor. Para eso, es:
  • Realiza las tareas de generar código Terraform desde el código de aplicación y, posteriormente, implementarlo en AWS o Azure;
  • Ejecuta la aplicación localmente, emula el entorno AWS (si es necesario) y proporciona la posibilidad de depuración IDE.

Una de las características clave de Kotless es su capacidad para incrustarse en las aplicaciones existentes. Kotless hace una implementación súper fácil de las aplicaciones Spring y KTOR existentes a las plataformas sin servidor de AWS y Microsoft Azure.

Empezando

Configuración del proyecto

Kotless usa Gradle para envolver el proceso de construcción existente e insertar la implementación en él.

Considere usar una de las últimas versiones de Gradle, comenzando con la versión 7.2 .

Básicamente, si ya usa Gradle, solo necesita hacer dos cosas.

En primer lugar, configure el complemento de Gradle Kotless.

Tendrá que decirle a Gradle dónde encontrar el complemento editando settings.gradle.kts :

pluginManagement {
    resolutionStrategy {
        this .eachPlugin {
            if (requested.id.id == " io.kotless " ) {
                useModule( " io.kotless:gradle: ${ this .requested.version} " )
            }
        }
    }

    repositories {
        maven(url = uri( " https://packages.jetbrains.team/maven/p/ktls/maven " ))
        gradlePluginPortal()
        mavenCentral()
    }
}

Y aplique el complemento:

 // Imports are necessary, for this example
import io.kotless.plugin.gradle.dsl.Webapp.Route53
import io.kotless.plugin.gradle.dsl.kotless

// Group may be used by Kotless DSL to reduce the number of introspected classes by package
// So, don't forget to set it
group = " org.example "
version = " 0.1.0 "


plugins {
    // Version of Kotlin should be 1.3.72+
    kotlin( " jvm " ) version " 1.5.31 " apply true

    id( " io.kotless " ) version " 0.2.0 " apply true
}

En segundo lugar, agregue Kotless DSL (o KTOR o arranque de resorte) como una biblioteca a su aplicación:

repositories {
    mavenCentral()
    // Kotless repository
    maven(url = uri( " https://packages.jetbrains.team/maven/p/ktls/maven " ))
}

dependencies {
    implementation( " io.kotless " , " kotless-lang " , " 0.2.0 " )
    implementation( " io.kotless " , " kotless-lang-aws " , " 0.2.0 " )
//    if you want to deploy to Microsoft Azure, just replace -aws with -azure    
//    implementation("io.kotless", "ktor-lang-azure", "0.2.0")


    // or for Ktor (Note, that `ktor-lang` depends on Ktor version 1.5.0)
    // implementation("io.kotless", "ktor-lang", "0.2.0")
    // implementation("io.kotless", "ktor-lang-aws", "0.2.0")
    // implementation("io.kotless", "ktor-lang-azure", "0.2.0")

    // or for Spring Boot (Note, that `spring-boot-lang` depends on Spring Boot version 2.3.0.RELEASE)
    // implementation("io.kotless", "spring-boot-lang", "0.2.0")
    // implementation("io.kotless", "spring-boot-lang-aws", "0.2.0")
    // implementation("io.kotless", "spring-boot-lang-azure", "0.2.0")
}

Tenga en cuenta que si usa KTOR o Spring Boot deberá reemplazar la dependencia existente de su proyecto con una dependencia especial de Kotless *-lang . Además, después de eso, deberá alinear la versión de las bibliotecas dependientes (como Spring Security) con la versión Bundled en *-lang (ver este párrafo)

Esto le brinda acceso a las interfaces DSL en su código y configura un despachador Lambda dentro de su aplicación.

Desplegando en la nube

Dependiendo de un caso de uso, es posible que desee implementar la aplicación en un AWS o Microsoft Azure.

Tenga en cuenta que si incluso no tiene una cuenta de nube, aún puede usar Kotless localmente para ejecutar y depurar su aplicación, solo use la tarea de Gradle local .

Desplegando a AWS

Si no tiene una cuenta de AWS, puede crearla siguiendo la simple instrucción de Hadi Hariri.

Si tiene una cuenta de AWS y desea realizar la implementación real, ¡configuremos todo para ello! Es bastante simple:

kotless {
    config {

        aws {
            storage {
                bucket = " kotless.s3.example.com "
            }

            profile = " example "
            region = " eu-west-1 "
        }
    }

    webapp {
        dns( " kotless " , " example.com " )
    }
}

Aquí configuramos la configuración de Kotless:

• el cubo, que se utilizará para almacenar lambdas y configuraciones;
• Configuración de Terraform con el nombre del perfil para acceder a AWS.

Luego configuramos una aplicación específica para implementar:

• Alias ​​Route53 para la aplicación resultante (necesita pre-crear un certificado ACM para el registro DNS).

¡Y esa es toda la configuración!

Desplegando a Azure

La implementación en Microsoft Azure también es bastante sencilla y simple:

kotless {
    config {
        azure {
            storage {
                storageAccount = " your-storage-account "
                container = " container-which-kotless-would-use "
            }

            terraform {
                backend {
                    resourceGroup = " your-resource-group "
                }
            }
        }
    }

    webapp {
        dns( " kotless " , " example.com " )
    }
}

Aquí configuramos la configuración de Kotless:

• el almacenamiento, que se utilizará para almacenar lambdas y configuraciones;
• Configuración de Terraform con el nombre del perfil para acceder a Azure.

Luego configuramos una aplicación específica para implementar:

• Azure DNS alias para la aplicación resultante (debe pre-crear certificado para el registro DNS).

¡Y esa es toda la configuración!

Aplicación de creación

Ahora puede crear su primera aplicación sin servidor con Kotless DSL:

@Get( " / " )
fun main () = " Hello world! "

O con ktor:

 class Server : Kotless () {
    override fun prepare ( app : Application ) {
        app.routing {
            get( " / " ) {
                call.respondText { " Hello World! " }
            }
        }
    }
}

O con la bota de primavera:

@SpringBootApplication
open class Application : Kotless () {
    override val bootKlass : KClass < * > = this :: class
}

@RestController
object Pages {
    @GetMapping( " / " )
    fun main () = " Hello World! "
}

Inicio local

Las aplicaciones basadas en Kotless pueden comenzar localmente como un servidor HTTP. Esta funcionalidad es compatible con todos los DSL.

Además, Kotless Local Start puede girar una emulación de AWS (requerido Docker). Simplemente instanciar su cliente de servicio de AWS utilizando anulación para Kotless Local Start:

 val client = AmazonDynamoDBClientBuilder .standard().withKotlessLocal( AwsResource . DynamoDB ).build()

Y habilitarlo en Gradle:

kotless {
    // <...>
    extensions {
        local {
            // enables AWS emulation (disabled by default)
            useAWSEmulation = true
        }
    }
}

Durante la ejecución local, LocalStack se iniciará y todos los clientes apuntarán a su punto final automáticamente.

La funcionalidad de inicio local no requiere ningún acceso al proveedor de la nube, por lo que puede verificar cómo se comporta su aplicación sin una cuenta AWS. Además, le brinda la posibilidad de depurar su aplicación localmente de su IDE.

Integración con aplicaciones existentes

Kotless puede implementar la aplicación Spring Boot o KTOR existente en la plataforma AWS Serverless. Para hacerlo, deberá configurar un complemento y reemplazar la dependencia existente con el DSL Kotless apropiado.

Para KTOR , debe reemplazar el motor existente (por ejemplo implementation("io.ktor", "ktor-server-netty", "1.5.0") ) con implementation("io.kotless", "ktor-lang", "0.1.6") . Tenga en cuenta que esta dependencia envuelve KTOR de la versión 1.5.0 , por lo que es posible que deba actualizar otras bibliotecas KTOR (como ktor-html-builder ) a esta versión.

Para el arranque de primavera, debe reemplazar el arranque que usa (por ejemplo implementation("org.springframework.boot", "spring-boot-starter-web", "2.3.0.RELASE) 2.4.2 con implementation("io.kotless", "spring-boot-lang", "0.1.6") .

Una vez terminado, puede presionar la tarea deploy y hacer que su servidor de aplicaciones sea sin servidor. Tenga en cuenta que aún podrá ejecutar la aplicación localmente a través de la tarea de Gradle local .

Características avanzadas

Si bien Kotless se puede utilizar como un marco para la creación rápida de aplicaciones sin servidor, tiene muchas más características que cubren diferentes áreas de aplicación.

Incluyendo, entre otros::

• Lambdas-calentamiento automático : Kotless crea programadores para ejecutar secuencias de calentamiento para nunca dejar sus lambdas frías. Como resultado, las aplicaciones bajo carga moderada no son vulnerables al problema de inicio de frío.
• Gestión de permisos : puede declarar qué permisos se requieren recursos de AWS para la aplicación a través de anotaciones sobre funciones, clases u objetos de Kotlin. Los permisos se otorgarán automáticamente.
• Recursos estáticos : Kotless implementará recursos estáticos en S3 y configurará CDN para ellos. Puede mejorar enormemente el tiempo de respuesta de su aplicación y es compatible con todos los DSL.
• Eventos programados : Kotless establece temporizadores para ejecutar @Scheduled trabajos a tiempo;
• Extensiones de Terraform : el código generado por Kotless puede extenderse mediante el código personalizado de Terraform;

Kotless está en desarrollo activo, por lo que actualmente estamos trabajando para extender esta lista con características tales como:

• Soporte de otras nubes: Kotless se basa en un esquema agnóstico de la nube, por lo que estamos trabajando en el apoyo de otras nubes.
• Soporte de aplicaciones multiplataforma: Kotless no utilizará ninguna biblioteca específica de la plataforma para darle la opción de un tiempo de ejecución Lambda (JVM/JS/Native).
• Implementación versionada: Kotless podrá implementar varias versiones de la aplicación y mantener una de ellas como activas.
• Concesión de permisos implícitos: Kotless podrá deducir los permisos de las llamadas de la función AWS SDK.
• Apoyo de los manejadores de eventos: Kotless generará suscripciones de eventos para manejadores de eventos anotados adecuadamente.

Ejemplos

Cualquier explicación se vuelve mucho mejor con un ejemplo adecuado.

En la carpeta de examples del repositorio, puede encontrar proyectos de ejemplo creados con Kotless DSL:

• kotless/site : un sitio sobre Kotless escrito con Kotless DSL (Site.kotless.io). Este ejemplo demuestra el uso de @StaticGet y @Get (rutas estáticas y dinámicas), así como la API de enlace.
• kotless/shortener : un acortador de URL simple escrito con Kotless DSL (short.kotless.io). Este ejemplo demuestra @Get (rutas dinámicas), @Scheduled (lambdas programadas), API de permisos (para acceso Dynamodb) y extensiones Terraform.

Existen ejemplos similares para KTOR:

• ktor/site - Un sitio sobre Kotless escrito con Ktor (ktor.site.kotless.io). Este ejemplo demuestra el uso static {...} y routing {...} .
• ktor/shortener - Un acortador de URL simple escrito con Ktor (ktor.short.kotless.io). Este ejemplo demuestra routing { ... } (rutas dinámicas), API de permisos (para el acceso Dynamodb) y las extensiones de Terraform.

Y para el arranque de primavera:

• spring/site : un sitio sobre Kotless escrito con Boot Spring (Spring.Site.Kotless.io). Este ejemplo demuestra el uso de estadísticas y @RestController .
• spring/shortener : un acortador de URL simple escrito con Boot Spring (Spring.short.kotless.io). Este ejemplo demuestra el uso de @RestController (rutas dinámicas), API de permisos (para acceso Dynamodb) y extensiones de Terraform.

¿Quieres saber más?

Puede echar un vistazo a Wiki donde se encuentra la documentación del cliente sobre Kotless.

Además de eso, el código Kotless en sí está ampliamente documentado, y puede echar un vistazo a sus interfaces para conocer mejor a Kotless.

Puede hacer preguntas y participar en discusiones en el canal #kotless en Kotlinlang Slack.

Expresiones de gratitud

Un agradecimiento especial a:

• Alexandra Pavlova (también conocido como Sunalex) para nuestro hermoso logotipo;
• Yaroslav Golubev por ayuda con la documentación;
• Gregor Billing por ayuda con el complemento de Gradle y más.