# Run a Server Manually

## Use the `fastapi run` Command

In short, use `fastapi run` to serve your FastAPI application:

<div class="termy">

```console
$ <font color="#4E9A06">fastapi</font> run <u style="text-decoration-style:single">main.py</u>
<font color="#3465A4">INFO    </font> Using path <font color="#3465A4">main.py</font>

           apply plugin: 'eclipse'
           import org.gradle.plugins.ide.eclipse.model.BuildCommand

           eclipse.project {
               natures += ['nature.a']
               buildCommand 'command1', argumentKey: 'arg'
           }
        """

        when:
        EclipseProject project = loadToolingModel(EclipseProject)

        then:
        project.projectNatures.size() == 2

# FastAPI CLI

**FastAPI CLI** is a command line program that you can use to serve your FastAPI app, manage your FastAPI project, and more.

When you install FastAPI (e.g. with `pip install fastapi`), it includes a package called `fastapi-cli`, this package provides the `fastapi` command in the terminal.

To run your FastAPI app for development, you can use the `fastapi dev` command:

<div class="termy">

```console

		// Timeout
		{probe.Failure, false, true, "", remote.ErrCommandTimedOut.Error() + ": command testcmd timed out", fmt.Errorf("%w: command testcmd timed out", remote.ErrCommandTimedOut)},
		// ExecProbeTimeout
		{probe.Unknown, true, false, "", "", fmt.Errorf("%w: command testcmd timed out", remote.ErrCommandTimedOut)},
	}

	for i, test := range tests {

	// Skip if we have a pattern and this test doesn't match.
	skip, err := ctx.register(name)
	if err != nil {
		return err
	}
	if skip {
		return nil
	}

	// Create command.
	var trace, stderr bytes.Buffer
	cmd := exec.Command("go", "run", progPath)
	cmd.Stdout = &trace
	cmd.Stderr = &stderr

	// Run trace program; the trace will appear in stdout.
	fmt.Fprintf(os.Stderr, "running trace program %s...\n", name)

Instead, copy the link to your latest build scan.

image::build-scan-2.png[]

== Enable Build Scans

To enable build scans on a gradle command, add `--scan` to the command line option:

[source,text]
----
 ./gradlew build --scan
----

You may be prompted to agree to the terms to use Build Scans.

    id: gopls-version
    attributes:
      label: "gopls version"
      description: "Output of `gopls -v version` on the command line"
    validations:
      required: true
  - type: textarea
    id: go-env
    attributes:
      label: "go env"
      description: "Output of `go env` on the command line in your workspace directory"
      render: shell
    validations:
      required: true
  - type: textarea

	}

	// Make sure it is digestible.
	cdargs := []string{"tool", "covdata", "percent", "-i", mdir}
	cmd := testenv.Command(t, testenv.GoToolPath(t), cdargs...)
	run(cmd, t)
}

func testCoverNoTestsNoFuncs(t *testing.T) {
	t.Parallel()
	dir := tempDir(t)

	// Run the cover command with "emit meta" enabled on a package
	// with no functions and no test files.
	tpath := filepath.Join("testdata", "pkgcfg")

{
  "kind": "PodExecOptions",
  "apiVersion": "v1",
  "stdin": true,
  "stdout": true,
  "stderr": true,
  "tty": true,
  "container": "containerValue",
  "command": [
    "commandValue"
  ]

func appendBSBytes(b []byte, n int) []byte {
	for ; n > 0; n-- {
		b = append(b, '\\')
	}
	return b
}

// readNextArg splits command line string cmd into next
// argument and command line remainder.
func readNextArg(cmd string) (arg []byte, rest string) {
	var b []byte
	var inquote bool
	var nslash int
	for ; len(cmd) > 0; cmd = cmd[1:] {
		c := cmd[0]