Creación de Entornos Virtuales y Configuración de FastAPI

Clase 3 de 23 • Curso de FastAPI

Contenido del curso

Introducción a FastAPI

Parámetros y Validación

CRUD en FastAPI

Arquitectura en FastAPI

12
Estructuración de Aplicaciones con FastAPI y API Router
09:37 min

Bases de Datos y Consultas

Middlewares

Unit Testing

Seguridad y Autenticación

Tomar examen

Resumen

Para trabajar con un framework en Python como FastAPI, siempre es recomendable emplear entornos virtuales. Estos entornos permiten gestionar las dependencias de un proyecto sin interferir con otros. A continuación, se explican los pasos clave para crear y configurar un entorno virtual y desarrollar una primera API básica.

¿Cómo crear un entorno virtual para FastAPI?

Crear el entorno virtual:
- Abre la terminal y navega a la carpeta donde se encuentra tu proyecto. Utiliza el módulo venv de Python para crear un entorno virtual:
```
python -m venv vm
```
- Esto generará un entorno virtual en una carpeta llamada vm dentro de tu proyecto.
Activar el entorno virtual:
- En sistemas Unix, ejecuta el siguiente comando:
```
source vm/bin/activate
```
- Esto permite aislar las dependencias de tu proyecto dentro del entorno virtual.

¿Cómo instalar FastAPI y sus dependencias?

Instalar FastAPI:
- Con el entorno virtual activo, instala FastAPI:
```
pip install "fastapi[standard]"
```
- Si recibes errores de interpretación, agrega comillas dobles para evitar problemas con las llaves {} que incluyen dependencias adicionales para la ejecución de FastAPI en entornos locales.
Verificar las dependencias instaladas:
- Tras la instalación, puedes listar las dependencias para observar los paquetes añadidos, como Jinja (templates), Markdown (manejo de texto) y Uvicorn (para ejecutar aplicaciones como servidor web).

¿Cómo crear un primer endpoint con FastAPI?

Configurar la estructura de archivos:
- Crea una carpeta para el proyecto:
```
mkdir curso_fastapi_project
```
- Dentro de esta carpeta, crea un archivo main.py para definir el primer endpoint.
Desarrollar la API en main.py:
- Abre el archivo en tu editor y añade el siguiente código básico:
```
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def root():
    return {"mensaje": "Hola, Mundo"}
```
- La función root define un endpoint básico que devuelve un mensaje JSON. Utiliza el decorador @app.get("/") para indicar que este endpoint responde a solicitudes GET en la ruta raíz (/).

¿Cómo ejecutar y probar la API en desarrollo?

Iniciar el servidor:
- Usa Uvicorn para ejecutar la aplicación:
```
uvicorn main:app --reload
```
- El parámetro --reload activa el modo de desarrollo, permitiendo recargar la API automáticamente cada vez que guardes cambios en el código.
Verificar en la terminal:
- Al ejecutar, Uvicorn muestra la URL de acceso a la API y la documentación generada automáticamente en /docs. Puedes acceder a la API en http://localhost:8000 y la documentación en http://localhost:8000/docs.

Comentarios

davidlopezfuentes

student•

Para activar el entorno virtual en Windows simplemente escribe:

curso-fastapi\Scripts\activate

Miguel Jaimes

student•

Gracias

PERCY LUIS CHE CASTILLO

student•

Al ejecutar: python3 -m venv venv curso-fastapi no se están creando dos (venv y curso-fastapi) entornos virtuales?

Andrés De La Torre Villa

student•

Sí, en WSL se crean los dos entornos que mencionas. Luis está utilizando MAC y aunque está basado en UNIX no se alcanza a visualizar si se crean ambos entornos virtuales o solo uno.

Cesar Augusto Mora Castilo

student•

Probé el comando en macOS y en wsl2, y si crea dos entornos virtuales con los nombres venv y curso-fastapi.

Alejandro Zapata

student•

Activar el entorno virtual en Windows:

curso-fastapi\Scripts\activate

Agustín Alberto Leiva

student•

Gracias, me funcionó

Eduardo Jimenez

student•

Este comentario deberia tener 100 likes y ser usado en la parte de obtener respuestas inmediatas

Erick Arellano

student•

Luis Escobedo

student••

Hago mi aporte sencillo:

from typing import Union
from fastapi import FastAPI
#Librerias para la fecha y hora
from datetime import date
from datetime import datetime
app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}

@app.get("/date")
def read_date():
    now = datetime.now()
    format = now.strftime('%d/%m/%Y')
    return {"Date": format} # Fecha actual en formato dd/mm/yyyy
@app.get("/time")
def read_time():
    now = datetime.now()
    format = now.strftime('%H:%M:%S')
    return {"Time": format} # Hora actual en formato hh:mm:ss

Abraham Josue Hurtado Urbina

student••

hice esto por la actividad :

from fastapi import FastAPI
from datetime import date, datetime
app = FastAPI()


@app.get("/")
async def root():
    return {"message": "Hello, luis!"}

@app.get("/datetime")
async def get_datetime():
    currentDate = date.today()
    currentTime = datetime.now().time()
    datetimeDetail = {
        "date": currentDate,
        "time": currentTime
    }
    return {"datetime": datetimeDetail}

Oscar Ivan Hernandez Manrique

student•

tengo el siguiente error y no se a que se debe ya inicie el entorno virtual pero al querer ejecutar el pip para instalar los paquetes me aparece el siguiente error

Santiago Salamanca Rusinque

student•

Hola, a mi me paso hace tiempo, es un tema de variables de entorno de windows, lo que sucede es que al momento de windows buscar la ruta para ejecutar python en el comando no la encuentra y se debe a que durante la instalación por xy motivo no se creo. Tienes que crearla manualmente, ya en teoria con eso deberia dejarte.

Disculpa la demora en responder pero mejor tarde que nunca jeje, en todo caso recuerda que la IA es una muy buena herramienta para comprender estos errores, adicional recuerda documentar como lo arreglaste, eso siempre puede ayudarte a futuro, o al alguien más.

Anthony Yegres

student•

El comando pip install "fastapi[standard]" instala FastAPI junto con dependencias adicionales cruciales como Uvicorn, Jinja y Markdown. Uvicorn es fundamental para correr tu aplicación como un servidor web, mientras que otros paquetes facilitan funciones como la generación automática de documentación.

Armando Rodriguez Flores

student•

El comando que compartes me esta creando dos folders en la misma ruta ~/ Sera possible tener mejor una estructura del tipo?: mkdir ~/projects

cd projects

mkdir curso-fastapi

cd curso-fastapi

python3 -m venv venv

Luis Martinez

teacher•

Solo ten cuidado de no subir la carpeta venv al repositorio, pero sí esa es una buena estructura.

Fredy Yecid Castro Agray

student••

from fastapi import FastAPI

from datetime import datetime

# con esta variable se crean los endpoints

app = FastAPI()

@app.get("/")

async def root():

return {"message":"hola mundo !!!!!"}

@app.get("/fecha")

async def fecha():

return {"message":datetime.now().date()}

thiago carrea

student•

from fastapi import FastAPI

from datetime import datetime

app=FastAPI()

@app.get('/')

async def root():

return {"message":"Hello Thiago xd"}

@app.get('/time')

async def time():

time = datetime.now()

return {"Time": time}

Jared De la O

student•

Could not find FastAPI app in module, try using --app

Carlos Arturo Rueda Calier

student•

from datetime import datetime

@app.get("/get-time")

async def get_time():

return {"current_time": datetime.now().isoformat()}

Samuel Alejandro Hurtado

student•

import datetime

from fastapi import FastAPI

app = FastAPI()

@app.get("/")

async def root():

return {"message": "Hello World"}

@app.get("/datetime")

async def datetime_now():

return {"datetime": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")}

# python3 -m venv venv curso_fastapi

# source venv/bin/activate

# pip install "fastapi[standard]"

# uvicorn main:app --reload

# mkdir curso-fast-api-project

# cd curso-fast-api-project

# source ../venv/bin/activate

Brayan coveñas

student•

y como brindo la ip a todo mi red local ? para hacer pruebas en otros dispositivos

Sergio Danilo Palacios Castillo

student•

Desde la terminal, puedes mirar la Ip asignada a tu computador para conectar otros dispositivos, en linux es _ip address._

Ahí busca la combinación **192.18.#.#.** Esa es la direccíon que debes usar

Pablo Rodriguez

student•

Perdón por mi ignorancia, soy nuevo en esto. Estoy utilizando PyCharm y quería saber: ¿cada vez que inicio un nuevo proyecto, el entorno virtual que se crea automáticamente es el mismo al que ustedes se refieren cuando hablan de crear uno usando los comandos que mencionaron?

davidlopezfuentes

student•

Para activar el entorno virtual en Windows simplemente escribe:

curso-fastapi\Scripts\activate
```curso-fastapi\Scripts\activate

Ronaldo Jiménez

student•

Reto:


from fastapi import FastAPI
import datetime


app = FastAPI()


@app.get("/")
async def root():
    return {"message": "Hola, JimcostDev!"}

## Ejercicio 1 - Crear una ruta que devuelva la fecha y hora actual
@app.get("/datetime")
async def datetime_now():
    return {"datetime": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")}

Santiago Salamanca Rusinque

student•

Dylan Laverde

student•

cuando coloco el comando code -r . me sale el error command not found: code, y seguí todos los pasos al pie de la letra, por que me pasa esto?

Hola Dylan. Ese error ocurre porque el comando code no está registrado en el "PATH" de tu sistema, lo que significa que tu terminal no sabe dónde está instalado Visual Studio Code.

Para solucionarlo rápidamente:

En macOS: Abre VS Code, presiona Cmd + Shift + P, escribe shell command y selecciona "Shell Command: Install 'code' command in PATH". Reinicia tu terminal.
En Windows: Durante la instalación de VS Code, debiste marcar la casilla que dice "Add to PATH". Si no lo hiciste, reinstala VS Code y asegúrate de marcar esa opción.

Como alternativa, puedes abrir la carpeta manualmente desde VS Code usando Archivo > Abrir carpeta.

Para profundizar en el manejo de herramientas, te recomiendo revisar: Creación de APIs rápidas y eficientes con FastAPI.

from typing import Union
from fastapi import FastAPI
#Librerias para la fecha y hora
from datetime import date
from datetime import datetime
app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}

@app.get("/date")
def read_date():
    now = datetime.now()
    format = now.strftime('%d/%m/%Y')
    return {"Date": format} # Fecha actual en formato dd/mm/yyyy
@app.get("/time")
def read_time():
    now = datetime.now()
    format = now.strftime('%H:%M:%S')
    return {"Time": format} # Hora actual en formato hh:mm:ss

from fastapi import FastAPI
from datetime import date, datetime
app = FastAPI()


@app.get("/")
async def root():
    return {"message": "Hello, luis!"}

@app.get("/datetime")
async def get_datetime():
    currentDate = date.today()
    currentTime = datetime.now().time()
    datetimeDetail = {
        "date": currentDate,
        "time": currentTime
    }
    return {"datetime": datetimeDetail}

from fastapi import FastAPI
import datetime


app = FastAPI()


@app.get("/")
async def root():
    return {"message": "Hola, JimcostDev!"}

## Ejercicio 1 - Crear una ruta que devuelva la fecha y hora actual
@app.get("/datetime")
async def datetime_now():
    return {"datetime": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")}

Creación de Entornos Virtuales y Configuración de FastAPI

Introducción a FastAPI

Creación de APIs rápidas y eficientes con FastAPI

Creación de APIs con FastAPI: Framework Rápido y Versátil