# Ejecutar un Servidor Manualmente { #run-a-server-manually }
## Usa el Comando `fastapi run` { #use-the-fastapi-run-command }
En resumen, usa `fastapi run` para servir tu aplicación FastAPI:
```console
$ fastapi run main.py
FastAPI Starting production server 🚀
Searching for package file structure from directories
with __init__.py files
Importing from /home/user/code/awesomeapp
module 🐍 main.py
code Importing the FastAPI app object from the module with
the following code:
from main import app
app Using import string: main:app
server Server started at http://0.0.0.0:8000
server Documentation at http://0.0.0.0:8000/docs
Logs:
INFO Started server process [2306215]
INFO Waiting for application startup.
INFO Application startup complete.
INFO Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C
to quit)
```
Eso funcionaría para la mayoría de los casos. 😎
Podrías usar ese comando, por ejemplo, para iniciar tu app **FastAPI** en un contenedor, en un servidor, etc.
## Servidores ASGI { #asgi-servers }
Vamos a profundizar un poquito en los detalles.
FastAPI usa un estándar para construir frameworks de web y servidores de Python llamado ASGI. FastAPI es un framework web ASGI.
Lo principal que necesitas para ejecutar una aplicación **FastAPI** (o cualquier otra aplicación ASGI) en una máquina de servidor remota es un programa de servidor ASGI como **Uvicorn**, que es el que viene por defecto en el comando `fastapi`.
Hay varias alternativas, incluyendo:
* Uvicorn: un servidor ASGI de alto rendimiento.
* Hypercorn: un servidor ASGI compatible con HTTP/2 y Trio entre otras funcionalidades.
* Daphne: el servidor ASGI construido para Django Channels.
* Granian: Un servidor HTTP Rust para aplicaciones en Python.
* NGINX Unit: NGINX Unit es un runtime para aplicaciones web ligero y versátil.
## Máquina Servidor y Programa Servidor { #server-machine-and-server-program }
Hay un pequeño detalle sobre los nombres que hay que tener en cuenta. 💡
La palabra "**servidor**" se utiliza comúnmente para referirse tanto al computador remoto/en la nube (la máquina física o virtual) como al programa que se está ejecutando en esa máquina (por ejemplo, Uvicorn).
Solo ten en cuenta que cuando leas "servidor" en general, podría referirse a una de esas dos cosas.
Al referirse a la máquina remota, es común llamarla **servidor**, pero también **máquina**, **VM** (máquina virtual), **nodo**. Todos esos se refieren a algún tipo de máquina remota, generalmente con Linux, donde ejecutas programas.
## Instala el Programa del Servidor { #install-the-server-program }
Cuando instalas FastAPI, viene con un servidor de producción, Uvicorn, y puedes iniciarlo con el comando `fastapi run`.
Pero también puedes instalar un servidor ASGI manualmente.
Asegúrate de crear un [entorno virtual](../virtual-environments.md){.internal-link target=_blank}, actívalo, y luego puedes instalar la aplicación del servidor.
Por ejemplo, para instalar Uvicorn:
```console
$ pip install "uvicorn[standard]"
---> 100%
```
Un proceso similar se aplicaría a cualquier otro programa de servidor ASGI.
/// tip | Consejo
Al añadir `standard`, Uvicorn instalará y usará algunas dependencias adicionales recomendadas.
Eso incluye `uvloop`, el reemplazo de alto rendimiento para `asyncio`, que proporciona un gran impulso de rendimiento en concurrencia.
Cuando instalas FastAPI con algo como `pip install "fastapi[standard]"` ya obtienes `uvicorn[standard]` también.
///
## Ejecuta el Programa del Servidor { #run-the-server-program }
Si instalaste un servidor ASGI manualmente, normalmente necesitarías pasar una cadena de import en un formato especial para que importe tu aplicación FastAPI:
```console
$ uvicorn main:app --host 0.0.0.0 --port 80
INFO: Uvicorn running on http://0.0.0.0:80 (Press CTRL+C to quit)
```
/// note | Nota
El comando `uvicorn main:app` se refiere a:
* `main`: el archivo `main.py` (el "módulo" de Python).
* `app`: el objeto creado dentro de `main.py` con la línea `app = FastAPI()`.
Es equivalente a:
```Python
from main import app
```
///
Cada programa alternativo de servidor ASGI tendría un comando similar, puedes leer más en su respectiva documentación.
/// warning | Advertencia
Uvicorn y otros servidores soportan una opción `--reload` que es útil durante el desarrollo.
La opción `--reload` consume muchos más recursos, es más inestable, etc.
Ayuda mucho durante el **desarrollo**, pero **no** deberías usarla en **producción**.
///
## Conceptos de Despliegue { #deployment-concepts }
Estos ejemplos ejecutan el programa del servidor (por ejemplo, Uvicorn), iniciando **un solo proceso**, escuchando en todas las IPs (`0.0.0.0`) en un puerto predefinido (por ejemplo, `80`).
Esta es la idea básica. Pero probablemente querrás encargarte de algunas cosas adicionales, como:
* Seguridad - HTTPS
* Ejecución en el arranque
* Reinicios
* Replicación (el número de procesos ejecutándose)
* Memoria
* Pasos previos antes de comenzar
Te contaré más sobre cada uno de estos conceptos, cómo pensarlos, y algunos ejemplos concretos con estrategias para manejarlos en los próximos capítulos. 🚀