cloude
1. Introduire le Cloud Native
Définir le Cloud
Cloud Computing : Accès à des ressources informatiques (serveurs, stockage, bases de
données) via Internet, en libre-service et à la demande.
Modèles de service : IaaS, PaaS, SaaS.
Modèles de déploiement : Public, Privé, Hybride.
Définir l’approche Cloud Native
Cloud Native : Méthodologie pour concevoir des applications optimisées pour le cloud, en
tirant parti de :
Conteneurs (Docker).
Orchestration (Kubernetes).
Microservices (découpage en services indépendants).
CI/CD (Automatisation des déploiements).
Résilience et scalabilité automatique.
2. Créer des APIs REST en [Link] et [Link]
Introduction à [Link] et Express
[Link] : Environnement JavaScript côté serveur (asynchrone, événementiel).
[Link] : Framework pour créer des APIs REST simplement.
Créer une API REST
const express = require('express');
const app = express();
[Link]('/api/hello', (req, res) => {
[Link]({ message: 'Hello Cloud Native!' });
});
[Link](3000, () => [Link]('API running on port 3000'));
Endpoints : GET , POST , PUT , DELETE .
Gérer les données : Utiliser body-parser pour les requêtes JSON.
Authentification avec JWT
JSON Web Tokens (JWT) : Standard pour l'authentification stateless.
Exemple :
const jwt = require('jsonwebtoken');
[Link]('/api/login', (req, res) => {
const token = [Link]({ user: 'admin' }, 'secret_key', { expiresIn: '1h' });
[Link]({ token });
});
3. Créer une Application Microservice
Initiation aux Architectures Microservices
Microservices : Découper une application en petits services indépendants, communiquant
via APIs (REST/gRPC).
Avantages : Scalabilité, isolation des pannes, déploiements indépendants.
Outils : Docker, Kubernetes, API Gateway (Express, NestJS).
Exemple d’Application Microservice
Service 1 : Gestion utilisateurs ( /users ).
Service 2 : Gestion commandes ( /orders ).
Communication : HTTP ou message broker (RabbitMQ).
4. Manipuler les Conteneurs avec Docker
Notion de Conteneur
Conteneur : Environnement isolé et portable pour exécuter une application.
Avantages : Isolation, reproductibilité, légèreté vs machines virtuelles.
Prendre en Main Docker
Commandes de base :
docker build -t mon-app . # Créer une image
docker run -p 3000:3000 mon-app # Lancer un conteneur
Docker Compose : Orchestrer plusieurs conteneurs (ex. : [Link] + MongoDB).
version: '3'
services:
web:
image: node:14
command: npm start
5. Déployer une Application Cloud Native sur
Azure
Introduction à Azure Cloud
Services Azure pertinents :
Azure App Service : Hébergement d’applications web (PaaS).
Azure Container Instances (ACI) : Exécution de conteneurs sans serveur.
Azure Kubernetes Service (AKS) : Orchestration de conteneurs.
Déploiement sur Azure App Service
1. Packager l’application (Docker ou directement via Git).
2. Créer une ressource "App Service" dans le portail Azure.
3. Déployer :
Via Azure CLI :
az webapp up --name mon-app-node --resource-group MonGroupeRessources
Via GitHub Actions (CI/CD automatisé).
Résumé des Étapes Clés
1. Comprendre le Cloud Native (Conteneurs, Microservices).
2. Développer une API REST ([Link] + Express + JWT).
3. Découper en Microservices.
4. Conteneuriser avec Docker.
5. Déployer sur Azure (App Service, AKS).
Comprendre les APIs et Créer une API REST
(simplifié)
1. Qu'est-ce qu'une API ?
Une API (Application Programming Interface) est un ensemble de règles qui permet à deux
logiciels de communiquer entre eux.
Exemple :
Quand une app mobile charge des données depuis un serveur, elle utilise une API.
Types d'APIs
1. REST API → La plus courante, utilise HTTP (GET, POST, etc.).
2. SOAP → Plus ancien, utilise XML.
3. GraphQL → Permet de demander uniquement les données nécessaires.
2. Qu'est-ce qu'une API REST ?
REST = Representational State Transfer
Fonctionne avec des requêtes HTTP :
GET → Récupérer des données.
POST → Envoyer des données.
PUT → Mettre à jour.
DELETE → Supprimer.
Exemple d'Endpoints REST
URL Méthode Action
/api/users GET Récupérer tous les users.
/api/users/1 GET Récupérer l'user avec l'ID 1.
/api/users POST Créer un nouvel user.
/api/users/1 PUT Mettre à jour l'user 1.
/api/users/1 DELETE Supprimer l'user 1.
3. Créer une API REST avec [Link] & Express
Étape 1 : Initialiser le projet
mkdir mon-api && cd mon-api
npm init -y
npm install express
Étape 2 : Créer un serveur Express basique
// [Link]
const express = require('express');
const app = express();
const PORT = 3000;
// Middleware pour parser le JSON
[Link]([Link]());
// Base de données temporaire (simulée)
let users = [
{ id: 1, name: "Alice" },
{ id: 2, name: "Bob" }
];
// GET tous les users
[Link]('/api/users', (req, res) => {
[Link](users);
});
// GET un user par ID
[Link]('/api/users/:id', (req, res) => {
const user = [Link](u => [Link] === parseInt([Link]));
if (!user) return [Link](404).send('User non trouvé');
[Link](user);
});
// POST un nouvel user
[Link]('/api/users', (req, res) => {
const newUser = {
id: [Link] + 1,
name: [Link]
};
[Link](newUser);
[Link](201).json(newUser);
});
// Démarrer le serveur
[Link](PORT, () => {
[Link](`Serveur démarré sur [Link]
});
Étape 3 : Tester l'API
GET All Users :
curl [Link]
GET User 1 :
curl [Link]
POST New User :
curl -X POST -H "Content-Type: application/json" -d '{"name":"Charlie"}'
[Link]
4. Ajouter l'authentification JWT (optionnel)
Installation des packages
npm install jsonwebtoken
Exemple de code pour JWT
const jwt = require('jsonwebtoken');
const SECRET_KEY = 'ma-clé-secrète';
// Route de login (simplifiée)
[Link]('/api/login', (req, res) => {
const { username, password } = [Link];
// Vérification factice (en vrai, utiliser une base de données)
if (username === "admin" && password === "123456") {
const token = [Link]({ username }, SECRET_KEY, { expiresIn: '1h' });
[Link]({ token });
} else {
[Link](401).json({ message: 'Identifiants incorrects' });
}
});
// Route protégée
[Link]('/api/protected', (req, res) => {
const token = [Link]?.split(' ')[1];
if (!token) return [Link](403).json({ message: 'Token manquant' });
[Link](token, SECRET_KEY, (err, decoded) => {
if (err) return [Link](401).json({ message: 'Token invalide' });
[Link]({ message: `Bienvenue, ${[Link]}!` });
});
});
Tester l'authentification
1. Login :
curl -X POST -H "Content-Type: application/json" -d
'{"username":"admin","password":"123456"}' [Link]
2. Accéder à une route protégée :
curl -H "Authorization: Bearer VOTRE_TOKEN" [Link]
5. Bonnes Pratiques pour les APIs REST
✅ Utiliser les bons codes HTTP (200 = OK, 404 = Not Found, etc.).
✅ Valider les données entrantes (éviter les erreurs).
✅ Documenter l'API (avec Swagger par exemple).
✅ Limiter les requêtes (pour éviter les abus).
Résumé
Une API REST permet à des applications de communiquer via HTTP.
[Link] + Express = moyen simple de créer une API.
JWT permet de sécuriser l'accès avec des tokens.
Besoin d'un exemple avec une base de données réelle (MongoDB) ? 😊