Nixpacks

A Kinsta oferece Nixpacks, um projeto de código aberto mantido pela Railway, como uma das opções para criar automaticamente a imagem do contêiner do seu aplicativo com base no seu repositório. Nixpacks são scripts executados quando seu aplicativo é implantado para instalar dependências e configurar seu ambiente.

Recomendamos que você use Nixpacks porque eles usam menos recursos e são compatíveis com mais de 20 linguagens. Você pode escolher Nixpacks ao adicionar um aplicativo ou ao alterar a opção Ambiente de build nas configurações do aplicativo (Configurações > Detalhes básicos > Editar detalhes).

Linguagens compatíveis

O Nixpacks é compatível com as seguintes linguagens:

  • Clojure
  • Cobol
  • Crystal
  • C#/.NET
  • Dart
  • Deno
  • Elixir
  • F#
  • Go
  • Haskell
  • Java
  • Lunatic
  • Node.js
  • PHP
  • Python
  • Rust
  • Swift
  • Scala
  • Zig

Para usar uma versão de linguagem diferente, defina a versão nos arquivos do aplicativo.

Quando você usa o Nixpacks, geralmente não precisa se preocupar em escolher ou adicionar diferentes fornecedores para a build, pois eles são identificados de forma automática. Caso o seu aplicativo precisar de fornecedores extras, você pode configurá-los facilmente em um arquivo de configuração do Nixpacks.

Se quiser usar uma linguagem que não seja compatível com Nixpacks ou buildpacks, você deverá usar um Dockerfile. Ao adicionar o aplicativo, você pode selecionar a opção Usar Dockerfile para configurar a imagem do contêiner.

Configurando o Nixpacks

Alguns aplicativos não exigem nenhuma configuração, mas alguns exigem comandos e opções especializados para serem executados, como:

Variáveis de ambiente – Talvez você precise definir determinadas variáveis de ambiente para executar o aplicativo.

Processos – A Kinsta pode detectar automaticamente o comando do seu processo da web. Você pode alterar isso, se necessário, e pode definir processos adicionais.

Processos em um Procfile – Talvez você queira definir seus processos em um Procfile dentro do código do aplicativo.

Diretórios binários do Nixpacks

Com o Nixpacks, os diretórios binários podem ser diferentes dos diretórios binários padrão da linguagem do aplicativo. A tabela a seguir mostra os diretórios binários usados para algumas das linguagens mais comuns:

LinguagemDiretório
Node.js/nix/var/nix/profiles/default/bin/node
Ruby/nix/var/nix/profiles/default/bin/ruby
Python/nix/var/nix/profiles/default/bin/python
Java/nix/var/nix/profiles/default/bin/java
ScalaO Scala não tem um caminho binário padrão específico como algumas outras linguagens compiladas. Quando você compila um programa Scala, ele gera bytecode executado na máquina virtual Java (JVM).

As classes Scala compiladas são normalmente armazenadas em uma estrutura de diretório que espelha a estrutura de pacote do seu código. Isso é semelhante à forma como as classes Java são organizadas. Por padrão, quando você compila um arquivo de código-fonte Scala, os arquivos .class compilados serão colocados no mesmo diretório que o código-fonte (dentro de uma estrutura de subdiretório baseada nas declarações de pacote).

Se necessário, você pode instalar as ferramentas de tempo de execução do Scala usando um Dockerfile em vez de usar um Nixpack.

PHP/nix/var/nix/profiles/default/bin/php
GoO Go não tem um caminho binário padrão específico como algumas outras linguagens compiladas. Quando você compila um programa em Go, o executável binário resultante é normalmente colocado no mesmo diretório que o código-fonte por padrão.

Se necessário, você pode instalar as ferramentas de tempo de execução do Go usando um Dockerfile em vez de usar um Nixpack.

Definindo a Versão da Linguagem em um Nixpack

Quando você seleciona a opção para Usar Nixpacks para configurar a imagem do contêiner, se você não especificar uma versão no código do seu aplicativo, o Nixpack usará a versão mais recente disponível. Se você deseja usar uma versão de linguagem diferente para o seu aplicativo, você precisará definir a versão nos arquivos do seu aplicativo ou, dependendo da linguagem, por meio de uma variável de ambiente.

Os métodos disponíveis para definir a versão variam de acordo com a linguagem. Abaixo, incluímos exemplos para as linguagens mais comuns.

Go

Para especificar a versão do Go, inclua o seguinte no arquivo go.mod do seu aplicativo:

go 1.18

Java

Para especificar a versão do Java, defina a variável de ambiente NIXPACKS_JDK_VERSION e certifique-se de que a variável esteja disponível durante o processo de build.

Se você estiver usando o Gradle, para especificar a versão, defina a variável de ambiente NIXPACKS_GRADLE_VERSION e certifique-se de que a variável esteja disponível durante o processo de build.

Node.js

Para especificar a versão do Node.js, siga um destes procedimentos:

Inclua o seguinte no arquivo package.json do seu aplicativo:

"engines": {
"node": "18"
}

Defina a variável de ambiente NIXPACKS_NODE_VERSION e certifique-se de que a variável esteja disponível durante o processo de build.

PHP

Para especificar sua versão do PHP, inclua o seguinte no arquivo composer.json do seu aplicativo:

{
  "require": {
    "php": "8.2"
  }
}

Python

Para especificar sua versão do Python, siga um destes procedimentos:

  • Inclua o seguinte no arquivo runtime.txt do seu aplicativo:
    python-3.10.6
  • Inclua o seguinte em um arquivo .python-version em seu repositório:
    3.10.6
  • Defina a variável de ambiente NIXPACKS_PYTHON_VERSION e certifique-se de que a variável esteja disponível durante o processo de build.

Scala

Para especificar a versão do Scala, inclua o seguinte no arquivo build.sbt do aplicativo:

scalaVersion := "3.2.2"
Este artigo foi útil?