> ## Documentation Index
> Fetch the complete documentation index at: https://docs.replit.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Configuração de Replit App

> Aprenda como configurar seu app Replit usando os arquivos .replit e replit.nix.

Os Replit Apps são configurados com dois arquivos: o `.replit` e o `replit.nix`. Eles afetam como o seu Replit App se comporta, desde a execução do código até as ferramentas de desenvolvimento e linguagens.

Esses arquivos de configuração estão ocultos por padrão. Exiba-os no seu Replit App selecionando "Show hidden files" no menu da árvore de arquivos.

![image](https://mintcdn.com/replit/rBzGsKp9NcWJ7sib/images/getting-started/show-hidden-files.png?fit=max\&auto=format\&n=rBzGsKp9NcWJ7sib\&q=85\&s=847e381d949d2432e58079ec166f1c08)

## Arquivo `replit.nix`

O Replit usa `Nix` para gerenciar pacotes e ambientes. O arquivo `replit.nix` é usado para:

**Especificar dependências do sistema:** Defina exatamente quais pacotes de software o seu Replit App requer, gerenciados pelo Nix, um gerenciador de pacotes.

**Criar ambientes reproduzíveis:** Garanta que seu ambiente de desenvolvimento seja consistente e reproduzível, ideal para projetos colaborativos e testes em múltiplos sistemas.

Você pode gerenciar pacotes Nix visualmente através da ferramenta `Dependencies`. Saiba mais no guia de [Dependências do Sistema](https://docs.replit.com/pt/references/workspace/dependency-management#system-dependencies).

Para configurar pacotes com o arquivo `replit.nix`, você pode listar [pacotes Nix](https://search.nixos.org/packages) no array `deps`, prefixados com `pkgs.`. Quaisquer alterações serão sincronizadas após seu shell ser recarregado.

```nix theme={null}
{ pkgs }: {
  deps = [
    pkgs.nodejs-19_x
    pkgs.nodePackages.typescript-language-server
    pkgs.yarn
    pkgs.replitPackages.jest
  ];
}
```

## Arquivo `.replit`

O arquivo `.replit` controla o comportamento do seu Replit App. Ele usa o [formato de configuração](https://toml.io/en/) `toml`. Aqui estão alguns dos principais aspectos que podem ser configurados:

**Comando Run:** Especifique o comando que é executado quando o botão Run é selecionado. Cada template tem um comando run padrão para permitir a execução de código imediatamente. Para apps mais personalizados e complexos, use [Workflows](https://docs.replit.com/pt/references/workspace/workflows).

**Language Server Protocol (LSP)**: Fornece recursos como auto-completar, navegação de código, destaque de código e linting e erros em tempo real.

**Variáveis de ambiente:** Defina e gerencie variáveis de ambiente essenciais para que suas aplicações funcionem corretamente.

**Dependências e pacotes:** Gerencie instalações de pacotes e configurações diretamente pelo arquivo `.replit`, garantindo que seu Replit App tenha todas as ferramentas necessárias prontas na inicialização. Você pode gerenciar dependências visualmente através da ferramenta `Dependencies`. Saiba mais no guia de [Módulos do Sistema](https://docs.replit.com/pt/references/workspace/dependency-management#advanced-configuration).

Para aplicações Python, o arquivo `.replit` padrão é:

```toml theme={null}
entrypoint = "main.py"
modules = ["python-3.10:v18-20230807-322e88b"]

[nix]
channel = "stable-23_05"

[unitTest]
language = "python3"

[gitHubImport]
requiredFiles = [".replit", "replit.nix"]

[deployment]
run = ["python3", "main.py"]
deploymentTarget = "cloudrun"
```

A tabela a seguir fornece uma visão de cada configuração no arquivo `.replit`, explicando o que cada configuração faz e seu impacto no ambiente do Replit App.

| **Chave de configuração** | **Valor/Exemplo** | **Descrição** |
| - | - | - |
| `entrypoint` | `main.py` | Especifica o arquivo principal a ser executado e exibido por padrão quando o editor é aberto. Você pode renomear o arquivo com base na sua aplicação. |
| `modules` | `["python-3.10:v18-20230807-322e88b"]` | Define versões específicas de linguagens de programação ou outras dependências principais suportadas pelo Replit. |
| `[nix]` | | Especifica configurações para usar o Nix, um gerenciador de pacotes, para gerenciar dependências do sistema. Consulte o documento de [Gerenciamento de Dependências](https://docs.replit.com/pt/references/workspace/dependency-management) para mais informações. |
| `channel` | `stable-23_05` | Indica o canal Nix a ser usado, o que afeta as versões das dependências do sistema disponíveis. |
| `packages` | `["cowsay", "htop"]` | Especifica alguns pacotes Nix para instalar. Para controle mais refinado, você também pode usar `replit.nix`. |
| `[unitTest]` | | Configura as definições relacionadas a testes unitários no Replit App. |
| `language` | `python3` | Especifica a linguagem usada para testes unitários, indicando que Python 3 é usado para escrever testes. |
| `[gitHubImport]` | | Configurações que afetam como os projetos são importados do GitHub, especificamente quais arquivos devem ser incluídos. |
| `requiredFiles` | `[".replit", "replit.nix"]` | Lista os arquivos que devem estar presentes ao importar o projeto para garantir que ele funcione corretamente. |
| `[deployment]` | | Contém configurações para fazer o deploy da aplicação do Replit App para um ambiente ativo. |
| `run` | `["python3", "main.py"]` | Comando executado para iniciar a aplicação durante o deployment. |
| `deploymentTarget` | `cloudrun` | Especifica a plataforma de destino do deployment para hospedar a aplicação. |

Agora que você tem uma ideia das configurações padrão do arquivo `.replit`, use as próximas seções para entender como configurar as definições básicas e avançadas para o seu Replit App.

## Configurando definições básicas

### Entrypoint

Este é o arquivo principal do seu projeto. Se você não definir uma propriedade `run`, o `entrypoint` é o arquivo executado pelo runtime.

```toml theme={null}
entrypoint = "<nome-do-arquivo>.py"
```

### Comando `Run`

A propriedade `run` no arquivo `.replit` é um recurso chave que determina o comando inicial ou série de comandos executados quando o botão `Run` é selecionado em um ambiente Replit. O comando `Run` pode ser especificado como uma string representando o comando a ser executado, ou como um array de strings representando o comando e os argumentos individuais para esse comando.

Algumas formas comuns de configurar o comando `Run`:

* **Comando único:**
  Este exemplo mostra como passar um único comando para executar diretamente no Replit App. Com isso no seu arquivo `.replit`, pressionar o botão `Run` exibirá uma saudação no painel `Console`:
  **Exemplo:** `run = "echo 'Hello, Replit!'"`

* **Argumentos explícitos:**
  Em algumas situações, pode ser benéfico ser mais explícito, evitando a necessidade de analisar aspas ou regras de interpolação do shell. Você pode reescrever o exemplo acima para separar os argumentos.
  Note que você não precisa mais de `'` e `"`, pois está passando explicitamente a saudação como o primeiro e único argumento para `echo`:
  **Exemplo:** `run = ["echo", "Hello, Replit!"]`

* **Múltiplos comandos:**
  Este exemplo mostra como executar múltiplos processos, como um frontend e um backend, simultaneamente. Isso pode ser útil ao desenvolver um backend Python e um frontend TypeScript, onde cada servidor se vincula a uma porta diferente:
  **Exemplo:** `run = "python -m app & npm run start & wait"`

#### Gerenciamento de processos

Embora múltiplos comandos possam ser executados simultaneamente com `&`, você pode querer uma experiência melhor para distinguir os logs entre serviços. Você pode [adicionar dependências do sistema](https://docs.replit.com/pt/references/workspace/dependency-management#system-dependencies) como [`process-compose`](https://github.com/F1bonacc1/process-compose) para orquestrar melhor múltiplos processos.

#### Fase `Build`

Para algumas linguagens ou runtimes, há uma fase de compilação separada antes que o código possa ser `executado`. Isso abrange tanto linguagens compiladas como TypeScript, Golang ou Java, quanto oferece um parâmetro que você pode usar para redefinir seu ambiente, dados ou configuração antes que o próximo `run` seja invocado.

* **Compilação:**
  Em um repositório TypeScript, você pode precisar executar `tsc` antes de executar seu código.
  **Exemplo:**

```toml theme={null}
build = "tsc app.ts"
run = "node app.js"
```

#### Incluindo variáveis de ambiente

Para fornecer variáveis de ambiente ao seu serviço antes da execução, você pode expandir a propriedade `run` em uma [tabela](https://toml.io/en/v1.0.0#table).

Esta é uma mudança mais complexa e provavelmente requer mover onde sua propriedade `run = "..."` está localizada dentro do arquivo `.replit`.

O diff a seguir mostra o fornecimento do comando por meio de `args` em `[run]`, bem como a variável `NAME` fornecida em `[run.env]`:

```diff theme={null}
-run = ["bash", "-c", "echo \"Hello, $NAME!\""]

 modules = ["nodejs-20"]

 hidden = [".pythonlibs"]

+# We need to move our new [run] down past all the
+# top-level properties that do not start with a `[`!
+[run]
+args = ["bash", "-c", "echo \"Hello, $NAME!\""]
+
+[run.env]
+NAME="Replit"

 [nix]
 channel = "stable-23_11"
```

#### Interatividade

Programas interativos também podem ser iniciados pelo botão `Run`, oferecendo uma forma de distinguir seu ambiente de desenvolvimento do terminal onde seu programa está sendo executado.
Considere o seguinte script de contagem:

**Exemplo**

```toml theme={null}
[run]
args = ["bash", "-c", """
count=0
while read -p "$PROMPT" -r next && [ -n "$next" ]; do
    count=$((count+next))
done
echo "The numbers you entered sum to $count!"
"""]

[run.env]
PROMPT = "Next number ([Enter] to end): "
```

## Opções de configuração avançadas

Explore as opções de configuração detalhadas disponíveis para o seu Replit App. Você pode personalizar seu ambiente de desenvolvimento, gerenciar comandos run, integrar serviços de linguagem e gerenciar dependências.

| **Configuração** | **Chave** | **Valor/Exemplo** | **Descrição** |
| - | - | - | - |
| onBoot | `onBoot` | `onBoot = "npm install"` | Comando que é executado quando o Replit App inicializa. |
| compile | `compile` | (Sem exemplo padrão) | Comando que é executado antes do comando `run`, usado em linguagens compiladas como C++. |
| language | `language` | `language = "javascript"` | Especifica a linguagem durante uma importação do GitHub ou ao criar um Replit App. |
| entrypoint | `entrypoint` | `entrypoint = "index.js"` | Arquivo principal a ser executado e exibido ao abrir o editor. |
| hidden | `hidden` | `hidden = [".config", "package-lock.json"]` | Arquivos ou pastas a ocultar por padrão na árvore de arquivos lateral. |
| audio | `audio` | `audio = true` | Habilita o Áudio em Todo o Sistema quando definido como `true`. |

### Notas sobre Áudio em Todo o Sistema

Ao definir `audio = true` no seu arquivo `.replit`, pode ser necessário executar `kill 1` em um shell para forçar a nova configuração a entrar em vigor.

Ao executar uma aplicação gráfica, você verá um par de fones de ouvido com uma caixa de seleção no canto inferior direito do painel `Output`.
Devido a restrições do navegador, isso precisará ser habilitado a cada vez que você atualizar.

```toml theme={null}
# Ensure this is at the top of your `.replit` file, outside of any `[`-bracketed section
audio = true
```

## Configuração do packager

| **Configuração** | **Chave** | **Valor/Exemplo** | **Descrição** |
| - | - | - | - |
| packager | `language` | `packager.language = "python3"` | Linguagem usada para operações de pacote. |
| packager features | `guessImports` | `packager.features.guessImports = true` | Adivinha automaticamente os pacotes a instalar antes de executar o Replit App. |
| packager features | `packageSearch` | `packager.features.packageSearch = true` | Habilita suporte para o packager quando definido como `true`. |
| packager features | `enabledForHosting` | `packager.features.enabledForHosting = false` | Define se a hospedagem do Replit App requer a execução de uma instalação de pacote. |
| packager | `afterInstall` | `afterInstall = "echo 'package installed'"` | Comando executado após um novo pacote ser instalado via packager. |
| packager | `ignoredPaths` | `ignoredPaths = [".git"]` | Caminhos a ignorar ao tentar adivinhar pacotes. |
| packager | `ignoredPackages` | `ignoredPackages = ["twitter", "discord"]` | Módulos que nunca devem tentar adivinhar um pacote durante a instalação. |

### Exemplo de configuração `.replit` para configuração do packager

```toml theme={null}
# Define the language for the Replit App
packager.language = "python3"

# Enable features for automatic package management
[packager.features]
guessImports = true
packageSearch = true
enabledForHosting = false

# Command to run after each package installation
packager.afterInstall = "echo 'Package installed successfully'"

# Define paths and packages that should be ignored by the package manager
packager.ignoredPaths = [".git", "node_modules"]
packager.ignoredPackages = ["twitter", "discord"]

# Additional deployment settings
[deployment]
run = ["python3", "app.py"]
```

## Configuração de deployment

| **Configuração** | **Chave** | **Valor/Exemplo** | **Descrição** |
| - | - | - | - |
| deployment | `run` | `deployment.run = "npm start"` | Comando que é executado quando um contêiner de Deployment inicia. |
| deployment | `build` | `deployment.build = "npm run build"` | Comando que é executado antes de rodar um Deployment. |
| deployment | `ignorePorts` | `deployment.ignorePorts = true` | Se `true`, o sucesso do deployment não requer uma verificação de porta aberta. |

### Exemplo de configuração `.replit` para configuração de deployment

```toml theme={null}

# Specifies the main entry point for the project
entrypoint = "app.js"

# Configuration settings for deploying the application
[deployment]
run = "npm start"
build = "npm run build"
ignorePorts = true
```

> [!NOTE]
>
> **A configuração do Interpreter** foi descontinuada e não está mais disponível no Replit. Em vez disso, você é encorajado a usar os comandos `Run` para configurar como scripts e aplicações são executados no seu ambiente Replit App.

## Configuração de porta

| **Configuração** | **Chave** | **Valor/Exemplo** | **Descrição** |
| - | - | - | - |
| ports | `localPort` | `localPort = 3000` | Porta que o Replit vincula a uma porta externa. |
| ports | `externalPort` | `externalPort = 80` | Porta acessível publicamente vinculada ao `localPort`. |

### Exemplo de arquivo de configuração `.replit` para gerenciar portas

```toml theme={null}
# Networking configuration to expose your application on specific ports
[[ports]]
localPort = 3000
externalPort = 80
```

## Acessando metadados do ambiente do Replit App

### Node.js

Para acessar todas as variáveis de ambiente:

`console.log(process.env);`

Para acessar uma única variável (REPL\_SLUG):

`console.log(process.env.REPL_SLUG);`

### Python

Para acessar todas as variáveis de ambiente:

```python theme={null}
import os
print(os.environ)
```

Para acessar uma única variável (REPL\_SLUG):

```python theme={null}
import os
variable = os.environ.get('REPL_SLUG')
print(variable)
```

### Rust

Para acessar todas as variáveis de ambiente:

```rust theme={null}
use std::env;
fn main() {
    for (key, value) in env::vars() {
        println!("{}: {}", key, value);
    }
}
```

Para acessar uma única variável (REPL\_SLUG):

```rust theme={null}
use std::env;
fn main() {
    let variable = env::var("REPL_SLUG").unwrap();
    println!("{}", variable);
}
```

## Variáveis de ambiente

A seguir estão as variáveis de ambiente acessíveis de dentro do seu Replit App:

| chave | descrição |
| - | - |
| `REPL_OWNER` | O nome de usuário do proprietário do Replit App. Se o seu Replit App é baseado em texto e não tem servidor web, `REPL_OWNER` refletirá o valor do usuário atual acessando o Replit App |
| `REPL_ID` | A string UUID única do seu Replit App |
| `HOME` | O caminho home do seu Replit App |
| `system` | O sistema operacional em execução no seu Replit App |
| `LANG` | Define a linguagem e a codificação de caracteres para o seu Replit App, afetando como o texto é processado e exibido |
| `REPL_IMAGE` | A imagem docker que corresponde ao seu Replit App |
| `REPL_LANGUAGE` | A linguagem de programação configurada para o seu Replit App, usada para determinar o ambiente de runtime e as ferramentas |
| `REPL_PUBKEYS` | Um objeto JSON em formato de string contendo diferentes chaves de API públicas |
| `REPL_SLUG` | Uma versão simplificada e legível por máquina do nome do Replit App, adequada para uso em URLs e nomes de arquivo |
| `PRYBAR_FILE` | O arquivo principal/entrypoint do seu Replit App |
| `REPLIT_DEV_DOMAIN` | Fornece a URL `replit.dev` para o seu Replit App no Project Editor. Note que esta variável de ambiente não está disponível em Deployments |