}

    public static class VagrantExecSpec {
        private String command;
        private String subcommand;
        private String[] args;
        private UnaryOperator<String> progressHandler;

        private VagrantExecSpec() {}

        public void setCommand(String command) {
            this.command = command;
        }

        public void setSubcommand(String subcommand) {

# Execute um Servidor Manualmente { #run-a-server-manually }

## Utilize o comando `fastapi run` { #use-the-fastapi-run-command }

Em resumo, utilize o comando `fastapi run` para inicializar sua aplicação FastAPI:

<div class="termy">

```console
$ <font color="#4E9A06">fastapi</font> run <u style="text-decoration-style:solid">main.py</u>

  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting production server 🚀

```

</div>

/// note | Remarque

La commande `uvicorn main:app` fait référence à :

* `main` : le fichier `main.py` (le « module » Python).
* `app` : l'objet créé dans `main.py` avec la ligne `app = FastAPI()`.

C'est équivalent à :

```Python
from main import app
```

///

Ici, je vais vous montrer comment utiliser Uvicorn avec des processus workers en utilisant la commande `fastapi` ou directement la commande `uvicorn`.

/// info | Info

# Test translation fixer tool { #test-translation-fixer }

## Code blocks with and without comments { #code-blocks-with-and-without-comments }

This is a test page for the translation fixer tool.

### Code blocks with comments { #code-blocks-with-comments }

The following code blocks include comments in different styles.
Fixer tool should fix content, but preserve comments correctly.

```python
# This is a sample Python code block
def hello_world():

Aquí te mostraré cómo usar **Uvicorn** con **worker processes** usando el comando `fastapi` o el comando `uvicorn` directamente.

/// info | Información

Si estás usando contenedores, por ejemplo con Docker o Kubernetes, te contaré más sobre eso en el próximo capítulo: [FastAPI en Contenedores - Docker](docker.md).

    }

    /**
     * Adds a single command-line argument to pass to the Python script.
     *
     * @param value the argument value to add
     * @return this PythonJob instance for method chaining
     */
    public PythonJob arg(final String value) {
        argList.add(value);
        return this;
    }

    /**
     * Adds multiple command-line arguments to pass to the Python script.
     *

package org.codelibs.fess.job;

import static org.codelibs.core.stream.StreamUtil.stream;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.SystemUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.codelibs.core.lang.StringUtil;
import org.codelibs.core.timer.TimeoutTask;

### Créer un Package

Exécutez la commande `package` et le fichier de release sera créé dans target/releases.

    $ mvn package
    $ mvn rpm:rpm   # package .rpm
    $ mvn jdeb:jdeb # package .deb

### Générer le Code Source

    $ mvn dbflute:download # (commande unique)
    $ mvn dbflute:freegen
    $ mvn license:format

### Tests d'Intégration

Una **imagen de contenedor** normalmente incluye en sus metadatos el programa o comando por defecto que debería ser ejecutado cuando el **contenedor** se inicie y los parámetros que deben pasar a ese programa. Muy similar a lo que sería si estuviera en la línea de comandos.

Cuando un **contenedor** se inicia, ejecutará ese comando/programa (aunque puedes sobrescribirlo y hacer que ejecute un comando/programa diferente).