kotless
0.2.0 - 2021-10-19
Kotless signifie Kotlin Serverless Framework.
Son objectif réside dans la réduction de la routine de la création de déploiement sans serveur en la générant directement à partir du code de l'application elle-même.
Donc, simplement parlant, Kotless vous donne un bouton magique pour déployer votre application Web en tant qu'application sans serveur sur AWS et Azure!
Kotless se compose de deux parties principales:
L'une des principales caractéristiques de Kotless est sa capacité à s'intégrer dans les applications existantes. Kotless facilite le déploiement super facile des applications Spring et KTOR existantes aux plates-formes AWS et Microsoft Azure Serverless.
Kotless utilise Gradle pour s'enrouler autour du processus de construction existant et y insérer le déploiement.
Pensez à utiliser l'une des dernières versions de Gradle, à commencer par la version 7.2 .
Fondamentalement, si vous utilisez déjà Gradle, il vous suffit de faire deux choses.
Tout d'abord, configurez le plugin Kotless Gradle.
Vous devrez dire à Gradle où trouver le plugin en modifiant 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()
}
}Et appliquer le plugin:
// 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
}Deuxièmement, ajoutez Kotless DSL (ou KTOR, ou Spring Boot) en tant que bibliothèque à votre application:
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")
} Veuillez noter que si vous utilisez KTOR ou Spring Boot, vous devrez remplacer existant dans votre dépendance de projet par une dépendance spéciale Kotless *-lang . De plus, après cela, vous devrez aligner la version des bibliothèques dépendantes (comme Spring Security) avec la version regroupée dans *-lang (voir ce paragraphe)
Cela vous donne accès aux interfaces DSL dans votre code et configure un répartiteur lambda dans votre application.
Selon un cas d'utilisation, vous pouvez déployer des applications dans un AWS ou Microsoft Azure.
Notez que si vous n'avez même pas de compte cloud, vous pouvez toujours utiliser Kotless localement pour exécuter et déboguer votre application - utilisez simplement la tâche de gradle local .
Si vous n'avez pas de compte AWS, vous pouvez le créer après une instruction simple de Hadi Hariri.
Si vous avez un compte AWS et que vous souhaitez effectuer le véritable déploiement, configurons tout pour ça! C'est plutôt simple:
kotless {
config {
aws {
storage {
bucket = " kotless.s3.example.com "
}
profile = " example "
region = " eu-west-1 "
}
}
webapp {
dns( " kotless " , " example.com " )
}
}Ici, nous configurons la configuration de Kotless lui-même:
Ensuite, nous avons configuré une application spécifique à déployer:
Et c'est toute la configuration!
Le déploiement de Microsoft Azure est également assez simple et 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 " )
}
}
Ici, nous configurons la configuration de Kotless lui-même:
Ensuite, nous avons configuré une application spécifique à déployer:
Et c'est toute la configuration!
Vous pouvez maintenant créer votre première application sans serveur avec Kotless DSL:
@Get( " / " )
fun main () = " Hello world! "Ou avec Ktor:
class Server : Kotless () {
override fun prepare ( app : Application ) {
app.routing {
get( " / " ) {
call.respondText { " Hello World! " }
}
}
}
}Ou avec la botte de printemps:
@SpringBootApplication
open class Application : Kotless () {
override val bootKlass : KClass < * > = this :: class
}
@RestController
object Pages {
@GetMapping( " / " )
fun main () = " Hello World! "
}Les applications basées sur Kotless peuvent démarrer localement en tant que serveur HTTP. Cette fonctionnalité est prise en charge par tous les DSL.
De plus, Kotless Local Start peut tourner une émulation AWS (Docker requise). Instanciez simplement votre client de service AWS en utilisant la priorité pour les départs locaux sans kot:
val client = AmazonDynamoDBClientBuilder .standard().withKotlessLocal( AwsResource . DynamoDB ).build()Et l'activer à Gradle:
kotless {
// <...>
extensions {
local {
// enables AWS emulation (disabled by default)
useAWSEmulation = true
}
}
}Pendant la course locale, LocalStack sera démarré et tous les clients seront automatiquement indiqués vers son point de terminaison.
La fonctionnalité de démarrage locale ne nécessite aucun accès au fournisseur de cloud, vous pouvez donc vérifier comment votre application se comporte sans compte AWS. En outre, cela vous donne la possibilité de déboguer votre application localement à partir de votre IDE.
Kotless est en mesure de déployer une application Spring Boot ou KTOR existante sur AWS Serverless Platform. Pour le faire, vous devrez configurer un plugin et remplacer la dépendance existante par le DSL Kotless approprié.
Pour KTOR , vous devez remplacer le moteur existant (par exemple implementation("io.ktor", "ktor-server-netty", "1.5.0") ) avec implementation("io.kotless", "ktor-lang", "0.1.6") . Notez que cette dépendance regroupe KTOR de la version 1.5.0 , vous devrez donc peut-être mettre à niveau d'autres bibliothèques KTOR (comme ktor-html-builder ) à cette version.
Pour Spring Boot, vous devez remplacer le démarreur que vous utilisez (par exemple implementation("org.springframework.boot", "spring-boot-starter-web", "2.3.0.RELASE) ) avec implementation("io.kotless", "spring-boot-lang", "0.1.6") . Remarque que cette version de dépendance de la version Spring Boot de la version 2.4.2 , afin que vous puissiez également avoir besoin de la version de la version Spring à la version printemps.
Une fois cela fait, vous pouvez toucher la tâche deploy et rendre votre serveur d'applications sans serveur. Remarquez que vous pourrez toujours exécuter une application localement via la tâche Gradle local .
Bien que Kotless puisse être utilisé comme cadre pour la création rapide d'applications sans serveur, il dispose de nombreuses autres fonctionnalités couvrant différents domaines d'applications.
Y compris, mais sans s'y limiter:
@Scheduled dans les délais;Kotless est en développement actif, nous travaillons donc actuellement sur l'extension de cette liste avec des fonctionnalités telles que:
Toute explication devient bien meilleure avec un bon exemple.
Dans le dossier examples du référentiel, vous pouvez trouver des exemples de projets construits avec Kotless DSL:
kotless/site - un site sur Kotless écrit avec Kotless DSL (site.kotless.io). Cet exemple démontre l'utilisation @StaticGet et @Get (routes statiques et dynamiques), ainsi que de l'API de liaison.kotless/shortener - Un raccourcisseur d'URL simple écrit avec Kotless DSL (Short.kotless.io). Cet exemple démontre @Get (dynamic itinéraires), @Scheduled (Lambdas planifié), API des autorisations (pour l'accès DynamoDB) et Terraform Extensions.Des exemples similaires existent pour KTOR:
ktor/site - Un site sur Kotless écrit avec Ktor (ktor.site.kotless.io). Cet exemple démontre l'utilisation static {...} et routing {...} .ktor/shortener - Un raccourcisseur d'URL simple écrit avec Ktor (Ktor.short.kotless.io). Cet exemple démontre routing { ... } (routes dynamiques), les autorisations API (pour l'accès DynamoDB) et les extensions Terraform.Et pour la botte de printemps:
spring/site - Un site sur Kotless écrit avec Spring Boot (printemps.site.kotless.io). Cet exemple démontre l'utilisation de la statistique et @RestController .spring/shortener - Un raccourcisseur d'URL simple écrit avec Spring Boot (Spring.short.kotless.io). Cet exemple démontre l'utilisation de @RestController (Routes dynamiques), API des autorisations (pour l'accès DynamoDB) et Terraform Extensions. Vous pouvez jeter un œil à Wiki où se trouve la documentation du client sur Kotless.
En dehors de cela, le code Kotless lui-même est largement documenté, et vous pouvez jeter un coup d'œil à ses interfaces pour mieux connaître Kotless.
Vous pouvez poser des questions et participer à des discussions sur #kotless Channel à Kotlinlang Slack.
Un merci spécial à:
