# FastAPI CLI

**FastAPI CLI** é uma interface por linha de comando do `fastapi` que você pode usar para rodar sua app FastAPI, gerenciar seu projeto FastAPI e mais.

Quando você instala o FastAPI (ex.: com `pip install fastapi`), isso inclui um pacote chamado `fastapi-cli`. Esse pacote disponibiliza o comando `fastapi` no terminal.

Para rodar seu app FastAPI em desenvolvimento, você pode usar o comando `fastapi dev`:

<div class="termy">

```console

	commandsTree := trie.NewTrie()

	// registerCommand registers a cli command.
	registerCommand := func(command cli.Command) {
		// avoid registering commands which are not being built (via
		// go:build tags)
		if command.Name == "" {
			return
		}
		commands = append(commands, command)
		commandsTree.Insert(command.Name)
	}

    protected int executeCommand(final String[] commands, final String username, final String password) {
        if (commands == null || commands.length == 0) {
            throw new CommandExecutionException("command is empty.");
        }

        if (logger.isInfoEnabled()) {
            logger.info("Command: {}", String.join(" ", commands));
        }

        final String[] cmds = stream(commands).get(stream -> stream.map(s -> {

#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
#         * compound commands having a testable exit status, especially «case»;
#         * various built-in commands including «command», «set», and «ulimit».
#
#   Important for patching:
#
#   (2) This script targets any POSIX shell, so it avoids extensions provided
#       by Bash, Ksh, etc; in particular arrays are avoided.
#

#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
#         * compound commands having a testable exit status, especially «case»;
#         * various built-in commands including «command», «set», and «ulimit».
#
#   Important for patching:
#
#   (2) This script targets any POSIX shell, so it avoids extensions provided
#       by Bash, Ksh, etc; in particular arrays are avoided.
#

  return 0
}

# runCommand ($@)
# Run custom mc command
runCommand() {
  ${MC} "$@"
  return $?
}

# Try connecting to MinIO instance
{{- if .Values.tls.enabled }}
scheme=https
{{- else }}
scheme=http
{{- end }}
connectToMinio $scheme

{{ if .Values.customCommands }}
# Run custom commands
{{- range .Values.customCommands }}
runCommand {{ .command }}
{{- end }}

                        * like writeandx will choke if session
                        * closes in between */
    }
    int getBatchLimit( byte command ) {
        if( command == SMB_COM_READ_ANDX ) {
            return READ_ANDX_BATCH_LIMIT;
        }
        if( command == SMB_COM_CLOSE ) {
            return CLOSE_BATCH_LIMIT;
        }
        return 0;
    }

    private byte[] b;

    SmbComWrite() {
        super();
        command = SMB_COM_WRITE;
    }
    SmbComWrite( int fid, int offset, int remaining, byte[] b, int off, int len ) {
        this.fid = fid;
        this.count = len;
        this.offset = offset;
        this.remaining = remaining;
        this.b = b;
        this.off = off;
        command = SMB_COM_WRITE;
    }

To start a stopped container, you can use the [`docker start`](https://docs.docker.com/engine/reference/commandline/start/) command.

```sh
docker start <container_id>
```

To stop a running container, you can use the [`docker stop`](https://docs.docker.com/engine/reference/commandline/stop/) command.

```sh
docker stop <container_id>
```

### MinIO container logs

@REM
@REM Environment Variable Prerequisites
@REM
@REM   JAVA_HOME           (Optional) Points to a Java installation.
@REM   MAVEN_BATCH_ECHO    (Optional) Set to 'on' to enable the echoing of the batch commands.
@REM   MAVEN_BATCH_PAUSE   (Optional) set to 'on' to wait for a key stroke before ending.
@REM   MAVEN_OPTS          (Optional) Java runtime options used when Maven is executed.