Open Exchange
Descrição
Este é um modelo para um aplicativo FastAPI que pode ser implantado no IRIS como um aplicativo Web nativo.
Instalação
- Clone o repositório
- Crie um ambiente virtual
- Instale os requisitos
- Execute o arquivo docker-compose
git clone
cd iris-fastapi-template
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
docker-compose up
Uso
A URL base é http://localhost:53795/fastapi/.
Endpoints
/iris- Retorna um objeto JSON com as 10 principais classes presentes no namespace IRISAPP./interop- Um endpoint de ping para testar a estrutura de interoperabilidade do IRIS./posts- Um endpoint CRUD simples para um objeto Post./comments- Um endpoint CRUD simples para um objeto Comentário.
Como desenvolver a partir deste template
Veja o artigo de introdução ao WSGI: wsgi-introduction.
TL;DR: Você pode ativar ou desativar o sinalizador DEBUG no portal de segurança para que as alterações sejam refletidas no aplicativo à medida que você desenvolve.
Apresentação do código
app.py
Este é o arquivo principal do aplicativo FastAPI. Ele contém o aplicativo FastAPI e as rotas.
from fastapi import FastAPI, Request
import iris
from grongier.pex import Director
# import models
from models import Post, Comment, init_db
from sqlmodel import Session,select
app = FastAPI()
# create a database engine
url = "iris+emb://IRISAPP"
engine = init_db(url)
from fastapi import FastAPI, Request- Importe a classe FastAPI e a classe Requestimport iris- Importe o módulo IRIS.from grongier.pex import Director: Importe a classe Director para vincular o aplicativo Flask ao framework de interoperabilidade do IRIS.from models import Post, Comment, init_db- Importe os modelos e a função init_db.from sqlmodel import Session,select- Importe a classe Session e a função select do módulo sqlmodel.app = FastAPI()- Crie um aplicativo FastAPI.url = "iris+emb://IRISAPP"-Defina o URL do namespace IRIS.engine = init_db(url)- Crie um mecanismo de banco de dados para o ORM sqlmodel..
models.py
Este arquivo contém os modelos para o aplicativo.
from sqlmodel import Field, SQLModel, Relationship, create_engine
class Comment(SQLModel, table=True):
id: int = Field(default=None, primary_key=True)
post_id: int = Field(foreign_key="post.id")
content: str
post: "Post" = Relationship(back_populates="comments")
class Post(SQLModel, table=True):
id: int = Field(default=None, primary_key=True)
title: str
content: str
comments: list["Comment"] = Relationship(back_populates="post")
Não há muito a dizer aqui, apenas a definição dos modelos com chaves estrangeiras e relacionamentos.
A função init_db é usada para criar o mecanismo de banco de dados.
def init_db(url):
engine = create_engine(url)
# create the tables
SQLModel.metadata.drop_all(engine)
SQLModel.metadata.create_all(engine)
# initialize database with fake data
from sqlmodel import Session
with Session(engine) as session:
# Create fake data
post1 = Post(title='Post The First', content='Content for the first post')
...
session.add(post1)
...
session.commit()
return engine
engine = create_engine(url)- Crie um mecanismo de banco de dados.SQLModel.metadata.drop_all(engine)- Exclua todas as tabelas.SQLModel.metadata.create_all(engine)- Crie todas as tabelas.with Session(engine) as session:- Crie uma sessão para interagir com o banco de dados.post1 = Post(title='Post The First', content='Content for the first post')- Crie um objeto Post..session.add(post1)-Adicione o objeto Post à sessão.session.commit()-Confirme as alterações no banco de dados.return engine- Retorne o mecanismo de banco de dados.
/iris endpoint
######################
# IRIS Query exemplo #
######################
@app.get("/iris")
def iris_query():
query = "SELECT top 10 * FROM %Dictionary.ClassDefinition"
rs = iris.sql.exec(query)
# Convert the result to a list of dictionaries
result = []
for row in rs:
result.append(row)
return result
@app.get("/iris")- Defina uma rota GET para o endpoint/iris.query = "SELECT top 10 * FROM %Dictionary.ClassDefinition"-Defina a consulta para obter as 10 principais classes no namespace IRIS.rs = iris.sql.exec(query)- Execute a consulta..result = []- Crie uma lista vazia para armazenar os resultados.for row in rs:- Itere sobre o conjunto de resultados.result.append(row)- Adicione a linha à lista de resultados.return result- Retorne a lista de resultados.
/interop endpoint
########################
# IRIS interop exemplo #
########################
bs = Director.create_python_business_service('BS')
@app.get("/interop")
@app.post("/interop")
@app.put("/interop")
@app.delete("/interop")
def interop(request: Request):
rsp = bs.on_process_input(request)
return rsp
bs = Director.create_python_business_service('BS')- Crie um business service Python.
-Deve ser criado fora da definição da rota para evitar múltiplas instâncias do serviço de negócios.@app.get("/interop")- Define uma rota GET para o endpoint/interop.@app.post("/interop")- Define uma rota POST para o endpoin/interop.- ...
def interop(request: Request):- Define o manipulador da rota.rsp = bs.on_process_input(request)- Chame o métodoon_process_inputdo business service.return rsp- Retorne a resposta.
/posts endpoint
############################
# operações CRUD de posts #
############################
@app.get("/posts")
def get_posts():
with Session(engine) as session:
posts = session.exec(select(Post)).all()
return posts
@app.get("/posts/{post_id}")
def get_post(post_id: int):
with Session(engine) as session:
post = session.get(Post, post_id)
return post
@app.post("/posts")
def create_post(post: Post):
with Session(engine) as session:
session.add(post)
session.commit()
return post
Este endpoint é usado para realizar operações CRUD no objeto Post.
Não há muito a dizer aqui, apenas a definição das rotas para obter todos os posts, obter um post por ID e criar um post.
Tudo é feito usando o ORM sqlmodel.
/comments endpoint
############################
# operações CRUD de comments #
############################
@app.get("/comments")
def get_comments():
with Session(engine) as session:
comments = session.exec(select(Comment)).all()
return comments
@app.get("/comments/{comment_id}")
def get_comment(comment_id: int):
with Session(engine) as session:
comment = session.get(Comment, comment_id)
return comment
@app.post("/comments")
def create_comment(comment: Comment):
with Session(engine) as session:
session.add(comment)
session.commit()
return comment
Este endpoint é usado para realizar operações CRUD no objeto Comment.
Não há muito a dizer aqui, apenas a definição das rotas para obter todos os comentários, obter um comentário por ID e criar um comentário.
Tudo é feito usando o ORM sqlmodel.
Solução de Problemas
Como executar o aplicativo FastAPI em modo autônomo
Você sempre pode executar um aplicativo Flask autônomo com o seguinte comando:
python3 /irisdev/app/community/app.py
Observação: você deve estar dentro do contêiner para executar este comando.
docker exec -it iris-fastapi-template-iris-1 bash
Reinicie o aplicativo no IRIS
Fique no modo DEBUG, faça várias chamadas para o aplicativo e as alterações serão refletidas no aplicativo.
Como acessar o Portal de Gerenciamento do IRIS
Você pode acessar o Portal de Gerenciamento do IRIS acessando
http://localhost:53795/csp/sys/UtilHome.csp.
Execute este template localmente
Para isso, você precisa ter o IRIS instalado em sua máquina.
Em seguida, você precisa criar um namespace chamado IRISAPP.
Instale os requisitos.
Instale IoP :
#init iop
iop --init
# load production
iop -m /irisdev/app/community/interop/settings.py
# start production
iop --start Python.Production
Configure o aplicativo no portal de segurança.