Como começar com os recursos sem servidor da DigitalOcean

0
36


O Functions é uma das mais recentes adições à plataforma em nuvem da DigitalOcean. Ele fornece um método de primeira classe para desenvolver funções sem servidor sem sair da DigitalOcean. Seu código é executado sob demanda quando chamado, eliminando o provisionamento e a manutenção manual do servidor.

Neste artigo, explicaremos o que o DigitalOcean Functions suporta e demonstraremos como criar sua própria função simples. O Functions tem um nível gratuito que fornece 25 GiB-horas por mês, com um GiB-segundo calculado como consumo de memória multiplicado pelo tempo de execução de cada chamada de função.

Recursos compatíveis

Lançado em maio de 2022, o Functions oferece aos clientes da DigitalOcean uma opção integrada para executar cargas de trabalho sem servidor. Cada função obtém seu próprio endpoint de API que executa o código que você criou. Você não precisa configurar seus próprios servidores ou conter o projeto antes da implantação. Os recursos ao vivo são hospedados no backend da plataforma de aplicativos da DigitalOcean.

Os recursos podem ser integrados aos bancos de dados gerenciados da DigitalOcean para facilitar o armazenamento de dados persistentes. Eles também vêm com uma CLI abrangente que permite implantar e testar seu código em seu terminal.

A versão inicial da plataforma suporta cinco ambientes de programação diferentes:

  • Vá 1,17
  • Node.js 14
  • Node.js 14 (suporta funções do AWS Lambda)
  • PHP8
  • Python 3.9

Você precisará se sentir à vontade para escrever seu código em uma dessas linguagens para implementá-lo como uma função. Mais tempos de execução podem ser suportados no futuro.

Preparando-se

Novos recursos podem ser lançados usando o painel de controle da Web da DigitalOcean ou o Doctl, sua CLI orientada ao desenvolvedor. Estamos nos concentrando na abordagem Doctl baseada em terminal para os propósitos deste artigo. Isso expõe todos os recursos do Functions e é o caminho pretendido para todos os casos de uso, exceto os mais simples. Certifique-se de ter a versão mais recente do Doctl instalada e autenticada em sua conta da DigitalOcean antes de continuar.

imagem dos recursos da DigitalOcean

Você precisará concluir algumas etapas de configuração adicionais se esta for a primeira vez que usa os recursos da DigitalOcean. Primeiro termine a instalação do Docl’s serverless extensão. Isso adiciona suporte completo para desenvolvimento e implantação de recursos.

$ doctl serverless install
Downloading...Unpacking...Installing...Cleaning up...
Done

Em seguida, conecte os recursos sem servidor à sua conta da DigitalOcean:

$ doctl serverless connect
Connected to function namespace 'fn-3c1d9001-8e04-44e8-9375-c22b13c4a41a' on API host 'https://faas-lon1-917a94a7.doserverless.co'

Agora você deve estar pronto para começar a escrever funções. execute o serverless status Comando para verificar se tudo funciona:

$ doctl serverless status
Connected to function namespace 'fn-3c1d9001-8e04-44e8-9375-c22b13c4a41a' on API host 'https://faas-lon1-917a94a7.doserverless.co'
Sandbox version is 3.1.1-1.2.1

A saída mostrada acima confirma que o suporte ao recurso está instalado e pronto para uso.

a serverless command é um alias de sandbox. No momento da escrita, as duas palavras-chave têm funcionalidade idêntica e são usadas de forma intercambiável na documentação da DigitalOcean. estamos padronizando serverless para este guia.

Criar uma função

Use o seguinte comando para criar um novo projeto de funções:

$ doctl serverless init --language js demo-project
A local sandbox area 'demo-project' was created for you.
You may deploy it by running the command shown on the next line:
  doctl sandbox deploy demo-project

Este comando cria uma nova função JavaScript dentro demo-project em seu diretório de trabalho. Inspecione o conteúdo deste diretório para ver o que o Doctl preparou para você:

$ tree demo-project
demo-project
├── packages
│   └── sample
│       └── hello
│           └── hello.js
└── project.yml

3 directories, 2 files

a project.yml O arquivo é onde você configura seu projeto de funções e os endpoints que ele fornece.

targetNamespace: ''
parameters: {}
packages:
  - name: sample
    environment: {}
    parameters: {}
    annotations: {}
    actions:
      - name: hello
        binary: false
        main: ''
        runtime: 'nodejs:default'
        web: true
        parameters: {}
        environment: {}
        annotations: {}
        limits: {}

O modelo inicial configura um pacote chamado sample. Dentro deste pacote, existe uma única ação (endpoint) chamada hello que é executado usando o Node. O código-fonte para esta ação é armazenado em packages/sample/hello/hello.js. Vejamos este arquivo abaixo:

function main(args) {
    let name = args.name || 'stranger'
    let greeting = 'Hello ' + name + '!'
    console.log(greeting)
    return {"body": greeting}
}

Este é um código JavaScript normal. a main() A função será chamada toda vez que sua função for chamada. Recebe um objeto contendo argumentos enviados como dados HTTP GET e POST na solicitação do usuário. Você também pode definir argumentos estáticos, usando o parameters campo em ações, pacotes e o projeto de nível superior em seu project.yml procedimentos.

As funções devem retornar um objeto que descreva a resposta HTTP ao problema. a body O campo se torna os dados incluídos na resposta.

Invocando e implantando funções

Este projeto está pronto para ser executado. Use este comando para implementar sua função:

$ doctl serverless deploy .
Deploying '/home/james/@scratch/demo-project'
  to namespace 'fn-3c1d9001-8e04-44e8-9375-c22b13c4a41a'
  on host 'https://faas-lon1-917a94a7.doserverless.co'
Deployment status recorded in '.nimbella'

Deployed functions ('doctl sbx fn get <funcName> --url' for URL):
  - sample/hello

a serverless deploy O comando recebe um argumento, o caminho para o diretório que contém suas funções. Usar . quando a raiz do seu projeto já é seu diretório de trabalho.

Agora você pode testar sua função usando a CLI:

$ doctl serverless functions invoke sample/hello -p name:howtogeek
{
    "body": "Hello howtogeek!"
}

a -p O parâmetro define um argumento que é passado para seu código. Este exemplo demonstra como o valor de retorno de sua função se torna o corpo da resposta HTTP.

Em seguida, tente fazer uma solicitação de API real para sua função. Você pode descobrir sua URL com o seguinte comando:

$ URL=$(doctl serverless functions get sample/hello --url)

Usar curl ou seu próprio cliente HTTP favorito para alcançar este endpoint:

$ curl $URL?name=howtogeek
Hello howtogeek!

a name O parâmetro de string de consulta foi passado com sucesso para a função.

Modificando sua função

Até agora estamos usando o código de exemplo da DigitalOcean sem nenhuma modificação. Isso não o levará muito longe em sua jornada sem servidor! edite seu hello.js arquivo para que fique assim:

function main(args) {
    return {
        body: {
            value: (args.value * 2),
            timestamp: Date.now()
        },
        headers: {
            "Content-Type": "application/json"
        }
    };
}

Reimplemente sua função:

$ doctl serverless deploy .

Esta função duplica ingenuamente o número dado pelo value parâmetro de solicitação. Ele também inclui um carimbo de data/hora com cada corpo de resposta. a headers O campo é usado no objeto de resposta para aplicar o JSON correto. Content-Type.

Você pode chamar esta função usando Docl ou curl no mesmo estilo de antes:

$ curl $URL?value=2
{
  "timestamp": 1654784122966,
  "value": 4
}

A reimplantação manual de sua função após cada alteração é tediosa e demorada. execute o watch comando enquanto trabalha para implementar automaticamente as alterações depois de modificar seus arquivos:

$ doctl serverless watch .
Watching '.' [use Control-C to terminate]

Mantenha a janela do terminal aberta enquanto você cria sua função. Cada nova implantação registrará uma mensagem para que você saiba quando poderá testar suas alterações. Isso facilita a iteração eficiente à medida que você desenvolve seus recursos.

Você também pode transmitir logs de suas funções. Isso é inestimável quando uma função falha ou não se comporta conforme o esperado. Execute este comando para acessar os logs associados à sua função de demonstração:

$ doctl serverless activations logs --follow --function sample/hello

Uma nova linha será impressa toda vez que você chamar sua função. Os logs também incluem mensagens que seu código emite para a saída padrão do ambiente e os fluxos de erro.

Implantação de produção

a serverless deploy Atualmente, o comando é projetado apenas para desenvolvimento. Você pode implantar na produção criando um repositório Git para seu projeto de função e executando-o usando a DigitalOcean Application Platform.

Crie um novo projeto no GitHub ou GitLab e carregue seu código:

$ git init
$ git remote add origin [email protected]:user/repo.git
$ git add .
$ git commit -m "initial commit"
$ git push -u origin master

imagem da criação de um aplicativo na plataforma de aplicativos da DigitalOcean

Em seguida, vá para o Painel da DigitalOcean e clique no link “Aplicativos” na barra lateral esquerda. Clique no botão “Criar aplicativo” que aparece. Na próxima tela, siga as instruções para se conectar à sua conta do GitHub e selecione seu novo repositório. Pressione o botão azul “Avançar”.

imagem da criação de um aplicativo na plataforma de aplicativos da DigitalOcean

A DigitalOcean detectará automaticamente seu repositório como um projeto do Functions se você tiver um project.yml na sua raiz. Clique no botão “Pular para revisão” para continuar.

imagem de um aplicativo de funções na plataforma de aplicativos da DigitalOcean

A próxima tela deve confirmar que você será cobrado no plano de Funções.

imagem de um aplicativo de funções na plataforma de aplicativos da DigitalOcean

Clique em “Criar recursos” para provisionar seu aplicativo e iniciar sua primeira implantação. O progresso será exibido no painel.

imagem de um aplicativo do Functions implantado na plataforma de aplicativos da DigitalOcean

Seus endpoints de função estarão acessíveis publicamente assim que a implantação for concluída. Você pode encontrar o padrão do seu aplicativo ondigitalocean.app domínio rolando para baixo a página Configurações do aplicativo em seu painel. Em nosso exemplo, o domínio do aplicativo é sea-lion-app.7ougx.ondigitalocean.app.

imagem de encontrar o domínio de um aplicativo na DigitalOcean App Platform

As funções são expostas automaticamente como URIs que têm o seguinte formato:

<app>.ondigitalocean.app/<function-package>/<function-action>

Você pode chamar a função de exemplo criada acima fazendo a seguinte solicitação:

$ curl https://sea-lion-app.7ougx.ondigitalocean.app/sample/hello?value=2
{
  "timestamp": 1654786505969,
  "value": 4
}

A função foi implementada com sucesso! Agora você pode usar a guia Domínios nas configurações do seu aplicativo para anexar um domínio personalizado em vez do padrão.

Resumo

O DigitalOcean Functions é o mais novo concorrente no campo cada vez mais lotado de funções sem servidor. A plataforma permite desenvolver funcionalidades do lado do servidor sem gerenciar máquinas virtuais ou conter manualmente seu código.

O Functions fornece uma CLI abrangente para construir e testar seus terminais. Você pode então implementar seus recursos na solução de plataforma de aplicativos existente da DigitalOcean, seja como um projeto independente ou como parte de um aplicativo maior.

Depois de ter uma função básica em execução, você pode consultar a documentação da DigitalOcean para começar a configurar comportamentos mais avançados. Você pode definir variáveis ​​de ambiente, várias ações e limites de recursos usando os campos em seu project.yml file, que oferece um caminho rápido e fácil para criar endpoints sob demanda relativamente complexos.