Les API

Les API (Application Programming Interface ou « Interface de Programmation d’Application »)  permet à une application ou un logiciel de pouvoir communiquer et interagir avec une autre application n’utilisant pas le même langage de programmation.
Différents types d’ API existent:

• Les API système : les API système libèrent les données des systèmes d’enregistrement stratégiques de l’entreprise. Parmi les systèmes stratégiques dont les données peuvent être libérées par les API, on trouve les systèmes ERP, les systèmes de gestion des clients et de la facturation, ainsi que les bases de données propriétaires. 
• Les API de processus : les API de processus interagissent avec les données et les façonnent au sein d’un système unique ou sur plusieurs systèmes, ce qui a l’avantage d’éliminer les silos. Les API de processus constituent un moyen de combiner des données et d’orchestrer plusieurs API système pour atteindre un objectif métier spécifique. La création d’une vue à 360 degré du client, l’exécution des commandes et l’état de l’expédition en sont quelques exemples. 
• Les API d’expérience : les API d’expérience fournissent un contexte aux données et processus libérés et établis à l’aide d’API système et d’API de processus. Les API d’expérience exposent les données destinées à être utilisées par les cibles prévues, comme les applications mobiles, les portails internes de données client, etc.

Ces API peuvent être Interne à l’entreprise soit une API privée, Externe à l’entreprise qui est donc publique et pour finir l’API Partenaire est un mixte des deux précédentes un accès restreint est mit en place afin que seulement des personnes autorisées même externe à l’entreprise puisse y avoir accès.

Aujourd’hui, il existe trois grandes catégories de protocoles ou d’architectures API : REST, RPC et SOAP. On peut les qualifier de « formats », chacun présentant des caractéristiques et des inconvénients spécifiques. Ils sont utilisés à des fins différentes.
REST. L’architecture REST (representational state transfer) est peut-être l’approche la plus populaire pour construire des API. REST s’appuie sur une relation client-serveur qui sépare les parties front et back-end de l’API et offre une flexibilité considérable en matière de développement et de mise en œuvre. REST est « stateless », ce qui signifie que l’API ne stocke aucun état ou donnée entre les requêtes. REST prend en charge la mise en cache, qui stocke les réponses pour les API lentes ou non sensibles au temps. Les API REST, généralement appelées « API RESTful », peuvent également communiquer directement ou fonctionner par le biais de systèmes intermédiaires tels que les passerelles API et les équilibreurs de charge.

RPC. Le protocole d’appel de procédure à distance (RPC) est un moyen simple d’envoyer plusieurs paramètres et de recevoir des résultats. Les API RPC invoquent des actions ou des processus exécutables, tandis que les API REST échangent principalement des données ou des ressources telles que des documents. Les RPC peuvent être codés en deux langages différents, JSON et XML ; ces API sont appelées respectivement JSON-RPC et XML-RPC.

SOAP. Le protocole SOAP (au départ, un acronyme de Simple Object Access Protocol, ce qui n’est plus le cas aujourd’hui) est une norme de messagerie définie par le World Wide Web Consortium et utilisée pour créer des API Web, généralement écrites en XML. SOAP prend en charge un large éventail de protocoles de communication que l’on trouve sur Internet, tels que HTTP, SMTP et TCP. SOAP est également extensible et indépendant du style, ce qui permet aux développeurs de concevoir des API SOAP de différentes manières et d’ajouter facilement des caractéristiques et des fonctionnalités. L’approche SOAP, par le biais de l’IDL Web Services Description Language (WSDL), détermine la manière dont le message est traité, les fonctionnalités et les modules inclus, le ou les protocoles de communication pris en charge et les messages SOAP sont écrits.

Dans le cadre d’un projet j’ai été amené à programmer une API REST dans le but de faire communiquer les différentes applications d’une entreprise. Pour cela j’ai utilisé le framework FATS API qui est en langage python 3,6+. L’architecture de l’API déployée est donc :

└── sql_app
├── __init__.py
├── crud.py
├── database.py
├── main.py
└── schemas.py
Elle permet la communication avec des bases de données relationnelles SQL. Afin de pouvoir mettre en application l’API il est nécessaire de se mettre dans un environnement virtuel. Pour cela il faut :

### Install pip3

`sudo apt-get install -y python3-pip`

### to install package

`pip3 install package_name`

### setup few more packages and development tools

`sudo apt-get install build-essential libssl-dev libffi-dev python-dev`

### install venv module

`sudo apt-get install -y python3-venv`

### create a enviornments

`python3 -m venv project_env`

Une fois cela fait, la documentation de FAST API est claire et précise. https://fastapi.tiangolo.com/tutorial/sql-databases/
Le fichier __init__.py: Est un fichier vide
Le fichier database.py: Définit l’URL de la base de données et son fonctionnement

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

SQLALCHEMY_DATABASE_URL = "sqlite:///./sql_app.db"
# SQLALCHEMY_DATABASE_URL = "postgresql://user:password@postgresserver/db"

engine = create_engine(
    SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Base = declarative_base()

Le fichier models.py: Définit le model utilisé pour la base de données

from sqlalchemy import Boolean, Column, ForeignKey, Integer, String
from sqlalchemy.orm import relationship

from .database import Base


class User(Base):
    __tablename__ = "users"

    id = Column(Integer, primary_key=True, index=True)
    email = Column(String, unique=True, index=True)
    hashed_password = Column(String)
    is_active = Column(Boolean, default=True)

    items = relationship("Item", back_populates="owner")


class Item(Base):
    __tablename__ = "items"

    id = Column(Integer, primary_key=True, index=True)
    title = Column(String, index=True)
    description = Column(String, index=True)
    owner_id = Column(Integer, ForeignKey("users.id"))

    owner = relationship("User", back_populates="items")

Le fichier schemas.py: Définit les formats des données utilisables

from typing import List, Optional

from pydantic import BaseModel


class ItemBase(BaseModel):
    title: str
    description: Optional[str] = None


class ItemCreate(ItemBase):
    pass


class Item(ItemBase):
    id: int
    owner_id: int

    class Config:
        orm_mode = True


class UserBase(BaseModel):
    email: str


class UserCreate(UserBase):
    password: str


class User(UserBase):
    id: int
    is_active: bool
    items: List[Item] = []

    class Config:
        orm_mode = True

Le fichier crud.py: Contient les fonctions permettant d’interpréter le langage de la base de données

from sqlalchemy.orm import Session

from . import models, schemas


def get_user(db: Session, user_id: int):
    return db.query(models.User).filter(models.User.id == user_id).first()


def get_user_by_email(db: Session, email: str):
    return db.query(models.User).filter(models.User.email == email).first()


def get_users(db: Session, skip: int = 0, limit: int = 100):
    return db.query(models.User).offset(skip).limit(limit).all()


def create_user(db: Session, user: schemas.UserCreate):
    fake_hashed_password = user.password + "notreallyhashed"
    db_user = models.User(email=user.email, hashed_password=fake_hashed_password)
    db.add(db_user)
    db.commit()
    db.refresh(db_user)
    return db_user


def get_items(db: Session, skip: int = 0, limit: int = 100):
    return db.query(models.Item).offset(skip).limit(limit).all()


def create_user_item(db: Session, item: schemas.ItemCreate, user_id: int):
    db_item = models.Item(**item.dict(), owner_id=user_id)
    db.add(db_item)
    db.commit()
    db.refresh(db_item)
    return db_item

Le fichier main.py: Est le coeur de communication il permet de faire interagir chaque fichier entre eux

from typing import List

from fastapi import Depends, FastAPI, HTTPException
from sqlalchemy.orm import Session

from . import crud, models, schemas
from .database import SessionLocal, engine

models.Base.metadata.create_all(bind=engine)

app = FastAPI()


# Dependency
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()


@app.post("/users/", response_model=schemas.User)
def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
    db_user = crud.get_user_by_email(db, email=user.email)
    if db_user:
        raise HTTPException(status_code=400, detail="Email already registered")
    return crud.create_user(db=db, user=user)


@app.get("/users/", response_model=List[schemas.User])
def read_users(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    users = crud.get_users(db, skip=skip, limit=limit)
    return users


@app.get("/users/{user_id}", response_model=schemas.User)
def read_user(user_id: int, db: Session = Depends(get_db)):
    db_user = crud.get_user(db, user_id=user_id)
    if db_user is None:
        raise HTTPException(status_code=404, detail="User not found")
    return db_user


@app.post("/users/{user_id}/items/", response_model=schemas.Item)
def create_item_for_user(
    user_id: int, item: schemas.ItemCreate, db: Session = Depends(get_db)
):
    return crud.create_user_item(db=db, item=item, user_id=user_id)


@app.get("/items/", response_model=List[schemas.Item])
def read_items(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    items = crud.get_items(db, skip=skip, limit=limit)
    return items

C’est ainsi qu’est composée l’API Rest qui permet une automatisation simple de la relation des application avec une base de données SQL.