Download kotless - Download de código fonte kotless

kotless

Dados do site

0.2.0 - 2021-10-19

Baixar

Kotless

Kotless significa Kotlin Serverless Framework.

Seu foco está em reduzir a rotina da criação de implantação sem servidor, gerando -a diretamente do código do próprio aplicativo.

Então, simplesmente falando, o Kotless oferece um botão mágico para implantar seu aplicativo da Web como um aplicativo sem servidor na AWS e no Azure!

Kotless consiste em duas partes principais:

O DSL fornece uma maneira de definir aplicativos sem servidor. Existem três DSLs suportados:
- Kotless DSL - Kotless Own DSL que fornece anotações para declarar roteamento, eventos programados, etc.
- KTOR - Motor Ktor que é introspecto por Kotless. Use a sintaxe Ktor padrão e o Kotless gerarão implantação.
- Spring Boot - Spring Boot Serverless Recainhe que é introspecto por Kotless. Use a sintaxe da mola padrão e o kotless gerarão implantação.
O plug -in gradle kotless fornece uma maneira de implantar o aplicativo sem servidor. Para isso, é:
- Executa as tarefas de gerar código de terraform a partir do código do aplicativo e, posteriormente, implantando -o na AWS ou no Azure;
- Executa o aplicativo localmente, emula o ambiente da AWS (se necessário) e fornece a possibilidade de depuração do IDE.

Um dos principais recursos do Kotless é a capacidade de incorporar aplicativos existentes. O Kotless facilita a implantação super fácil dos aplicativos de primavera e KTOR existentes para as plataformas sem servidor AWS e Microsoft Azure.

Começando

Configurando o projeto

Kotless usa o gradle para envolver o processo de construção existente e inserir a implantação nele.

Considere usar uma das versões mais recentes do Gradle, começando com a versão 7.2 .

Basicamente, se você já usa o gradle, só precisa fazer duas coisas.

Em primeiro lugar, configure o plug -in Kotless Gradle.

Você terá que dizer a Gradle onde encontrar o plug -in 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()
    }
}

E aplique o 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
}

Em segundo lugar, adicione Kotless DSL (ou KTOR, ou Spring Boot) como uma biblioteca ao seu aplicativo:

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")
}

Observe que, se você usar o ktor ou a inicialização da mola, precisará substituir a existência de dependência do seu projeto por uma dependência especial de Kotless *-lang . Além disso, você precisará alinhar a versão de bibliotecas dependentes (como a segurança da primavera) com a versão agrupada em *-lang (veja este parágrafo)

Isso fornece acesso às interfaces DSL em seu código e configura um despachante Lambda dentro do seu aplicativo.

Implantando para a nuvem

Dependendo de um caso de uso, você pode implantar o aplicativo em um AWS ou Microsoft Azure.

Observe que, se você nem tiver uma conta em nuvem, ainda poderá usar o Kotless localmente para executar e depurar seu aplicativo - basta usar a tarefa local Gradle.

Implantando para a AWS

Se você não possui uma conta da AWS, pode criá -la seguindo instruções simples de Hadi Hariri.

Se você tem uma conta da AWS e deseja executar a implantação real - vamos configurar tudo para ela! É bastante simples:

kotless {
    config {

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

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

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

Aqui, configuramos a configuração do próprio Kotless:

o balde, que será usado para armazenar lambdas e configurações;
Configuração do Terraform com o nome do perfil para acessar a AWS.

Em seguida, configuramos um aplicativo específico para implantar:

Alias da Route53 para o aplicativo resultante (você precisa pré-criar um certificado ACM para o registro DNS).

E essa é toda a configuração!

Implantando para o Azure

A implantação para o Microsoft Azure também é bastante direta e simples:

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 " )
    }
}

Aqui, configuramos a configuração do próprio Kotless:

o armazenamento, que será usado para armazenar lambdas e configurações;
Configuração do Terraform com o nome do perfil para acessar o Azure.

Em seguida, configuramos um aplicativo específico para implantar:

Alias do Azure DNS para o aplicativo resultante (você precisa pré-criar o certificado para o registro DNS).

E essa é toda a configuração!

Criação de aplicativos

Agora você pode criar seu primeiro aplicativo sem servidor com o Kotless DSL:

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

Ou com Ktor:

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

Ou com a bota de primavera:

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

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

Início local

Os aplicativos baseados em kotless podem começar localmente como um servidor HTTP. Essa funcionalidade é suportada por todos os DSLs.

Além disso, o começo local sem kot pode aumentar uma emulação da AWS (o docker necessário). Basta instanciar seu cliente de serviço da AWS usando a substituição para iniciações locais sem kot:

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

E habilitá -lo em Gradle:

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

Durante a execução local, o LocalStack será iniciado e todos os clientes serão apontados para o seu terminal automaticamente.

A funcionalidade de inicialização local não requer acesso ao provedor de nuvem; portanto, você pode verificar como seu aplicativo se comporta sem uma conta da AWS. Além disso, ele oferece a possibilidade de depurar seu aplicativo localmente do seu IDE.

Integração com aplicações existentes

O Kotless é capaz de implantar o aplicativo Spring Boot ou Ktor existente na plataforma AWS Serverless. Para fazer isso, você precisará configurar um plug -in e substituir a dependência existente pelo DSL sem kotless.

Para o KTOR , você deve substituir o mecanismo existente (por exemplo, implementation("io.ktor", "ktor-server-netty", "1.5.0") ) pela implementation("io.kotless", "ktor-lang", "0.1.6") . Observe que essa dependência agrupa Ktor da versão 1.5.0 , portanto, pode ser necessário atualizar outras bibliotecas KTOR (como ktor-html-builder ) para esta versão.

Para a inicialização da mola, você deve substituir o motor de partida que você usa (por exemplo implementation("org.springframework.boot", "spring-boot-starter-web", "2.3.0.RELASE) ) com a implementação (" Io.kotless "," Spring-boot-lanç "," 2.4.2 implementation("io.kotless", "spring-boot-lang", "0.1.6") . versão.

Depois de concluído, você pode atingir a tarefa deploy e tornar seu aplicativo sem servidor. Observe que você ainda poderá executar o aplicativo localmente através da tarefa local Gradle.

Recursos avançados

Embora o Kotless possa ser usado como uma estrutura para a rápida criação de aplicativos sem servidor, ele possui muitos outros recursos que cobrem diferentes áreas de aplicação.

Incluindo, mas não limitado a:

Lambdas Auto-Warming -Kotless cria agendadores para executar sequências de aquecimento para nunca deixar seu Lambdas frio. Como resultado, as aplicações sob carga moderada não são vulneráveis a um problema de partida a frio.
Gerenciamento de permissões - você pode declarar quais permissões as recursos da AWS são necessárias para aplicação por meio de anotações nas funções, classes ou objetos de Kotlin. As permissões serão concedidas automaticamente.
Recursos estáticos - A Kotless implantará recursos estáticos no S3 e configurará a CDN para eles. Pode melhorar bastante o tempo de resposta do seu aplicativo e é suportado por todas as DSLs.
Eventos programados - Kotless configura temporizadores para executar trabalhos @Scheduled no cronograma;
Extensões de Terraform -O código gerado por Kotless pode ser estendido pelo Código Terraform personalizado;

Kotless está em desenvolvimento ativo, por isso estamos trabalhando atualmente na extensão desta lista com os recursos como:

Suporte a outras nuvens-Kotless é baseado em um esquema agnóstico da nuvem, por isso estamos trabalhando no apoio a outras nuvens.
Suporte a aplicativos multiplataforma-Kotless não usará nenhuma biblioteca específica da plataforma para oferecer a você a opção de um tempo de execução do Lambda (JVM/JS/Native).
Implantação de versão - Kotless poderá implantar várias versões do aplicativo e manter uma delas como ativa.
Permissões implícitas para concessão - Kotless poderá deduzir permissões das chamadas de função da AWS SDK.
Suporte para manipuladores de eventos - Kotless gerará assinaturas de eventos para manipuladores de eventos devidamente anotados.

Exemplos

Qualquer explicação se torna muito melhor com um exemplo adequado.

Na pasta examples do repositório, você pode encontrar exemplos de projetos construídos com o Kotless DSL:

kotless/site - Um site sobre Kotless escrito com Kotless DSL (site.kotless.io). Este exemplo demonstra o uso @StaticGet e @Get (rotas estáticas e dinâmicas), bem como a API de link.
kotless/shortener - Um encurtador de URL simples escrito com DSL sem kot (short.kotless.io). Este exemplo demonstra @Get (rotas dinâmicas), @Scheduled (lambdas programada), API de permissões (para acesso ao dynamoDB) e extensões de Terraform.

Exemplos semelhantes existem para Ktor:

ktor/site - Um site sobre Kotless escrito com Ktor (ktor.site.kotless.io). Este exemplo demonstra static {...} e routing {...} uso.
ktor/shortener - Um encurtador de URL simples escrito com ktor (ktor.short.kotless.io). Este exemplo demonstra routing { ... } (rotas dinâmicas), API de permissões (para acesso ao DynamoDB) e Extensões Terraform.

E para a bota da primavera:

spring/site - Um site sobre Kotless escrito com a Spring Boot (spring.site.kotless.io). Este exemplo demonstra o uso de estática e @RestController .
spring/shortener - Um encurtador de URL simples escrito com a bota de mola (spring.short.kotless.io). Este exemplo demonstra o uso de @RestController (rotas dinâmicas), API de permissões (para acesso ao DynamoDB) e extensões de Terraform.