Créer la ressource

1. Dans le portail Azure, recherchez Azure Database for PostgreSQL. Sélectionnez Azure Database for PostgreSQL listé dans la section Marketplace.
2. Sélectionnez Azure Database for PostgreSQL Flexible server pour le type de ressource et cliquez sur Créer.
3. Dans l'onglet Généralités, configurez les attributs de la ressource. Le Tableau 12.1 présente la liste des paramètres à utiliser. Tout paramètre non inclus dans le tableau doit être défini sur les valeurs par défaut fournies dans l'assistant.

   Paramètres de l'onglet Généralités
   Abonnement	Sélectionnez l'abonnement par défaut.
   Groupe de ressources	Pour cet exemple, rg-nativeapps-eastus est utilisé.
   Nom du serveur	Saisissez un nom unique pour la ressource. Pour cet exemple, na-dbserver-flex est utilisé.
   Source de données	Sélectionnez Aucun.
   Emplacement	Pour cet exemple, sélectionnez la région utilisée pour le groupe de ressources.
   Version	Sélectionnez 11.
   Calcul + stockage	Cliquez sur le lien Configurer le serveur. Dans le volet Configurer, sélectionnez De base, définissez la valeur vCore sur 1 et le stockage sur 2 GiB, puis cliquez sur Enregistrer.
   Nom d'utilisateur administrateur	Saisissez un nom d'utilisateur. Pour cet exemple, Student est utilisé.
   Mot de passe	Saisissez un mot de passe. Pour cet exemple, Pa55w0rd1234 est utilisé.

   Tableau 12.1 Configuration de la base de données PostgreSQL
4. Pour créer les ressources telles que configurées dans le Tableau 12.1, cliquez sur Vérifier + créer, puis sur Créer. Le provisionnement du serveur de base de données peut prendre plusieurs minutes. Un message d'état apparaît lorsque le déploiement est terminé. Cliquez sur Accéder à la ressource.

Configurer la sécurité de la connexion

Des politiques de sécurité doivent être ajoutées pour permettre aux ressources, y compris tous les microservices, de se connecter à la base de données de manière sécurisée. Cette étape configure les paramètres de sécurité de la connexion afin que les microservices puissent s'y connecter de manière sécurisée. Cela se fait sur la page Sécurité de la connexion pour la ressource de base de données.

1. Dans le menu de gauche, sous Paramètres, cliquez sur Réseau.
   • Activez le serveur de base de données pour autoriser la connectivité depuis l'application infonuagique native déployée et exécutée dans Azure. Pour ce faire, cliquez sur Oui pour Autoriser l'accès aux services Azure. Immédiatement en dessous de cette configuration, cliquez sur + Ajouter l'adresse IP du client actuel (Figure 12.37).

     

     Figure 12.37 Il est important de configurer les paramètres de sécurité de la connexion afin que les microservices puissent s'y connecter de manière sécurisée. (Utilisé avec l'autorisation de Microsoft)
   • Pour cet exemple, désactivez les paramètres SSL. Si cette étape a été omise avant le provisionnement de la base de données, procédez comme suit : cliquez sur Paramètres du serveur. Dans le champ de recherche, recherchez « require_secure_transport ». Cliquez sur Désactivé (Figure 12.38).

     

     Figure 12.38 Assurez-vous de désactiver les paramètres SSL. (Utilisé avec l'autorisation de Microsoft)
   • Cliquez sur Enregistrer.
2. Dans le menu de gauche, cliquez sur Vue d'ensemble. Notez les valeurs du nom du serveur et du nom d'utilisateur administrateur. Ces valeurs sont utilisées pour se connecter à la base de données depuis l'application infonuagique native déployée et exécutée dans Azure.

Créer la base de données, les tables et les données initiales

La base de données est maintenant configurée avec un nom d'hôte et un compte utilisateur valides. L'étape suivante consiste à créer une base de données et des tables pour stocker les données. Une fois la base de données et les tables créées, des données initiales sont insérées.

1. Ouvrez l'Azure Cloud Shell. Pour ce faire, cliquez sur l'icône Cloud Shell à droite de la barre de recherche dans le portail Azure. Dans le cadre inférieur de la page du navigateur, le Cloud Shell se chargera. Cliquez sur Bash, si vous y êtes invité lors du chargement du Cloud Shell. Cliquez sur Créer un stockage si vous y êtes invité pour terminer le chargement du Cloud Shell.
2. Dans Cloud Shell, connectez-vous à la base de données avec la commande psql suivante. Insérez les valeurs du nom du serveur et du nom d'utilisateur administrateur obtenues précédemment pour <server_name> et <username>, respectivement, comme indiqué ci-dessous. Une invite de commande postgres apparaît. psql –host=<server_name> --port=5432 –username=<user_name> --dbname=postgres
3. Créez la base de données, créez une table et insérez les données qui seront utilisées dans cet exemple.
   • Exécutez l'instruction SQL ci-dessous pour créer une nouvelle base de données PostgreSQL. Le nom de la base de données utilisé dans cet exemple est cnainventory. CREATE DATABASE cnainventory;
   • Exécutez la commande ci-dessous pour basculer vers la base de données nouvellement créée. Cette étape est nécessaire pour que les tables soient créées dans la bonne base de données. \c cnainventory
   • Exécutez l'instruction SQL ci-dessous pour créer une nouvelle table. La table créée pour cet exemple est inventory. Elle contient quatre champs : id, qui est la clé primaire, name, quantity et date. CREATE TABLE inventory(     id serial PRIMARY KEY,     name VARCHAR(50),     quantity INTEGER,     date DATE NOT NULL DEFAULT NOW()::date );
   • Confirmez que la table inventory a été créée à l'aide de la commande suivante. \dt
   • Insérez des données dans la table inventory avec les instructions SQL ci-dessous. INSERT INTO inventory VALUES (1,'yogurt', 200); INSERT INTO inventory VALUES (2,'milk', 100);
   • Confirmez que les données ont été insérées avec succès à l'aide de la commande suivante : SELECT *FROM inventory;
   • La sortie liste les enregistrements de données.
   • Tapez \q pour vous déconnecter de la base de données.

Créer le service dorsal

Le premier microservice créé est le service dorsal. Ce service expose un ensemble de fonctions qui peuvent recevoir des requêtes via une REST (REST) API (API) qui insère des données d'inventaire dans la base de données.

1. Ouvrez l'Azure Cloud Shell. Pour ce faire, cliquez sur l'icône Cloud Shell à droite de la barre de recherche dans le portail Azure. Dans le cadre inférieur de la page du navigateur, le Cloud Shell se chargera. Cliquez sur Bash, si vous y êtes invité lors du chargement du Cloud Shell. Cliquez sur Créer un stockage si vous y êtes invité pour terminer le chargement du Cloud Shell.
2. Créez un répertoire pour l'application et naviguez-y avec la commande suivante. mkdir -p can-node-express && cd can-node-express
3. Utilisez la commande pour initialiser un projet Node. Un fichier package.json, entre autres fichiers, est généré pour le projet Node. Le fichier package.json est mis à jour pour inclure les dépendances du service dorsal Node/Express.js. npm init -y
4. Express.js est utilisé pour construire l'API REST pour le service dorsal. Installez Express.js avec la commande suivante. Confirmez que le fichier package.json est mis à jour en listant express comme dépendance. npm install express
5. Créez un nouveau fichier nommé index.js avec la commande code index.js et ajoutez le code ci-dessous. Pour enregistrer le fichier, tapez CTRL+S. Fermez le fichier en tapant CTRL+Q. Le code crée un serveur d'application Express qui écoute sur le port 8080. Il accepte les requêtes client envoyées au format JSON. const express = require('express') const port = process.env.PORT ǁ 8080 const app = express() app.use(express.json()) app.listen(port, () => console.log('Sample app is listening on port ${port}!'))

Connecter l'application infonuagique native à la base de données

Maintenant que le service dorsal a été créé avec succès, l'étape suivante consiste à ajouter du code à l'application Express.js qui lui permet de se connecter à la base de données. La technique de mappage objet-relationnel (ORM) (object-relational mapping (ORM)) convertit un objet de données dans le code Express.js en une table dans la base de données relationnelle PostgreSQL. Sequelize (Sequelize) est utilisé à cette fin.

1. Dans Azure Cloud Shell, exécutez la commande ci-dessous pour installer le package Sequelize. npm i sequelize pg pg-hstore
2. Modifiez le fichier index.js pour ajouter du code qui permet à l'application Express.js de se connecter à la base de données cnainventory. Insérez le code ci-dessous. Remplacez la valeur du nom du serveur par <server_name> (apparaît deux fois). Ce code fournit le nom d'hôte de connexion et le compte utilisateur à la base de données afin que le service dorsal puisse s'y connecter. const Sequelize = require('sequelize') const sequelize = new Sequelize('postgres://Student%40<server_name>:Pa55w0rd1234@<server_name>.postgres.database.azure.com:5432/cnainventory) sequelize .authenticate() .then(() => {   console.log('Connection has been established successfully.'); }) .catch(err => {   console.error('Unable to connect to the database:', err); });
3. Pour utiliser Sequelize dans l'application Express.js, ajoutez le code suivant au fichier index.js. C'est le code qui effectue le mappage entre les objets de données dans le code Express.js et les enregistrements de données dans la table de la base de données. La variable Inventory est déclarée pour définir le mappage entre le code Express.js et la table inventory. Notez que cette définition contient exactement les mêmes champs que ceux déclarés dans la table inventory de la base de données PostgreSQL cnainventory lors de sa création. const Inventory = sequelize.define('inventory', {   id: { type: Sequelize.INTEGER, allowNull: false, primaryKey: true },   name: { type: Sequelize.STRING, allowNull: false },   quantity: { type: Sequelize.INTEGER },   date: { type: Sequelize.DATEONLY, defaultValue: Sequelize.NOW } }, {   freezeTableName: true,   timestamps: false });

Créer les points d'extrémité de l'API REST Express.js

Maintenant que l'application Express.js est configurée pour accéder à la base de données PostgreSQL, l'étape suivante consiste à créer l'API REST pour accepter les requêtes client. Ces routes REST appellent des fonctions qui effectuent des opérations de lecture et d'écriture sur la base de données PostgreSQL. Deux routes Express.js sont ajoutées dans le code. La première route effectue une lecture de la base de données en réponse à la réception d'une requête HTTP GET. La seconde route effectue une écriture dans la base de données en réponse à la réception d'une requête HTTP POST.

1. Modifiez le fichier index.js et ajoutez le code affiché. Le code ajoute une route qui accepte les requêtes HTTP GET pour récupérer un enregistrement d'inventaire. L'ID de l'enregistrement est inclus dans la requête, et les champs ID, nom, quantité et date de l'enregistrement d'inventaire sont renvoyés. app.get('/inventory/:id', async=> {   const id=req.params.id   try { const inventory = await Inventory.findAll({   attributes: ['id', 'name', 'quantity', 'date'],   where: {     id: id   } })   res.json({ inventory }) } catch {   console.error }})
2. Ajoutez la deuxième route en ajoutant le code suivant au fichier index.js. Le code ajoute une route qui accepte les requêtes HTTP POST pour créer un nouvel enregistrement d'inventaire. Les valeurs de l'enregistrement sont incluses dans le corps de la requête HTTP, à l'exception de la date, qui est calculée à partir de la date actuelle. app.post('/inventory', async => { try {   const newItem = new Inventory(req.body)   await newItem.save()   res.json({ inventory: newItem }) } catch {   Console.error }})

Créer le composant frontal

Le second microservice créé est le service web (web service) frontal. Ce service web fournit une interface utilisateur web pour récupérer les données d'inventaire.

1. Dans l'Azure Cloud Shell, utilisez cette commande pour créer une application Next.js. npx create-next-app
2. Répondez aux invites. Il est important de sélectionner Non pour l'invite App Router. Notez que le nom du projet est cna-next. C'est le répertoire racine de l'application Next.js.
3. Naviguez dans le répertoire cna-next.
4. Rappelez-vous que dans le dorsal, l'application Express.js Sequelize (Sequelize) est utilisée comme ORM pour convertir les objets de données du code Express.js en enregistrements de données dans la table inventory de la base de données. Prisma (Prisma) est un ORM Node utilisé pour mapper des objets de données à des tables dans une base de données relationnelle.
   • Installez les packages prisma et prisma-client avec les commandes suivantes. npm install prisma npm install @prisma/client
   • Configurez l'application Next.js pour utiliser Prisma en exécutant la commande. Cela crée le sous-répertoire prisma/ et génère le fichier de configuration schema.prisma à l'intérieur. Cette commande génère également un fichier dotenv (.env) dans le répertoire racine du projet. npx prisma init
   • Dans le répertoire prisma/, modifiez le fichier schema.prisma généré et ajoutez le contenu présenté à la Figure 12.39. Cela ajoute le modèle de données pour la table inventory.

     

     Figure 12.39 Ce contenu ajoute le modèle de données pour la table inventory. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)
   • Notez comment schema.prisma est configuré pour lire l'URL de la base de données source à partir d'un fichier dotenv (.env). Dans le répertoire cna-next/, modifiez le fichier dotenv (.env) généré et modifiez la chaîne de connexion de la base de données comme indiqué dans l'extrait de code ci-dessous. Remplacez USER_NAME par Nom d'administrateur, PASSWORD par Mot de passe, et SERVER_NAME par Nom du serveur pour la base de données PostgreSQL cnainventory. DATABASE_URL="postgresql://USER_NAME%40SERVER_NAME:PASSWORD@SERVER_NAME.postgres.database.azure.com:5432/cnainventory"
   • Faites une copie du fichier .env et nommez-la .env.local car c'est ce fichier qui sera copié dans le conteneur Docker et utilisé par Prisma.
   • Pour utiliser Prisma dans l'application Next.js, le client Prisma doit être configuré. Le client Prisma sert de constructeur de requêtes adapté aux données de l'application. Les constructeurs de requêtes font partie de l'ORM qui génèrent les requêtes SQL utilisées pour effectuer les opérations de base de données pour l'application. Pour ce faire, exécutez la commande : npx prisma generate
   • Ajoutez le code du client Prisma à l'application Next.js. Pour ce faire, créez le sous-répertoire lib/ et naviguez-y.
   • Dans le répertoire lib/, créez le fichier prisma.tsx et ajoutez le code suivant. import { PrismaClient } from '@prisma/client' const globalForPrisma = global as unknown as { prisma: PrismaClient | undefined } export const prisma = globalForPrisma prisma ?? new PrismaClient({ log: ['query'], }) if(process.env.NODE_ENV !=='production') globalForPrisma.prisma = prisma
5. Maintenant que l'application Next.js est configurée pour se mapper à la table inventory, l'étape suivante consiste à implémenter le code du service web. Le code du service web se compose de composants React qui s'affichent dans un navigateur. Le composant React InventoryProps est un tableau d'enregistrements de données une fois récupérés de la base de données. Le composant React Inventory implémente la manière dont les données sont affichées sous forme de page web dans le navigateur. Le composant React Layout ajoute une navigation supplémentaire à la page web.
   • Dans le répertoire cna-next/ :
     • Créez et naviguez vers un répertoire nommé components/ et ajoutez-y les deux fichiers de code suivants (confirmez que le répertoire components/ est au même niveau que le répertoire pages/ qui a été généré) :
     • Créez le fichier Inventory.tsx et ajoutez le code suivant. import React from "react"; export type InventoryProps = {   id: string;   name: string;   quantity: string;   date: string; }; constInventory: React.FC<{ inventoryrec: InventoryProps }>=({ inventoryrec})=> {return(   <div   className="flex bg-white shadow-lg rounded-lg mx-2 md:mx-auto mb-5 max-w-2xl"   >   <divclassName="flex items-start px-4 py-3">     <div className="">       <div className="inline items-center justify-between">         <p className="text-gray-700 text-sm">         <strong>ID: {inventoryrec.id}</strong> Name: {inventoryrec.name} (quantity: {inventoryrec.quantity})         </p>         <small className="text-red-700 text-sm">         Date: {inventoryrec.date.toString().substring(0,10)}         </small>       </div>     </div>   </div> </div> </div> ); }; export default Inventory;
     • Créez le fichier Layout.tsx et ajoutez le code suivant. import React,{ ReactNode } from "react"; import Head from "next/head"; type Props = {   children: ReactNode; }; const Layout: React.FC<Props> = (props) => (   <div>     <div className="w-full text-center bg-red-800 flex flex-wrap items-center">       <div className="text-3xl w-1/2 text-white mx-2 md:mx-auto py-5">         Inventory Data       </div>   </div>   <div className="layout">{props.children}</div>   <style jsx global>{`     html {       box-sizing: border-box;     }     *,     *:before,     *:after {       box-sizing: inherit;     }     body {       margin: 0;       padding: 0;       font-size: 16px;       font-family: -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,         Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji",         "Segoe UI Symbol";       background: rgba(0,0,0,0.05);     }     input,     textarea {       font-size: 16px;     }     button {       cursor: pointer;     }   `}</style>   <style jsx>{`     .layout {       padding: 0 2rem;     }   `}</style>   </div> ); export default Layout;
   • Modifiez le fichier index.tsx et remplacez le code par défaut par le code suivant. declare global {   namespace NodeJS {     interface Global {       prisma: any;     }   } } import { prisma } from '../lib/prisma'; import Inventory,{ InventoryProps } from "../components/Inventory"; import Layout from "../components/Layout" export const getServerSideProps = async () => {   const inventoryrecs = await prisma.inventory.findMany({   })   return { props: { inventoryrecs: JSON.parse(JSON.stringify) } } } type Props = {   inventoryrecs: InventoryProps[] } // index.tsx const InventoryFeed: React.FC<Props> = (props) => {   return (     <Layout>       <div className="page">         <br/>         <main>           {props.inventoryrecs.map( => (             <div key={inventoryrec.id} className="post">               <Inventory inventoryrec={inventoryrec} />             </div>           ))}         </main>       </div>       <style jsx>{`         .post:hover {           box-shadow: 1px 1px 3px #aaa;         }         .post + .post {           margin-top: 2rem;         }       `}</style>     </Layout>   ) } export default InventoryFeed

Créer le registre de conteneurs Azure

1. Dans le portail Azure, sur la page d'accueil, cliquez sur Créer une ressource. Cliquez sur Registre de conteneurs.
2. Dans l'onglet Généralités, configurez les attributs de la ressource. Le Tableau 12.2 présente la liste des paramètres à configurer dans l'onglet Généralités. Tout paramètre non inclus doit être défini sur les valeurs par défaut fournies dans l'assistant.

   Paramètres de l'onglet Généralités
   Abonnement	Sélectionnez l'abonnement par défaut.
   Groupe de ressources	Pour cet exemple, rg-nativeapps-eastus est utilisé.
   Nom du registre	Saisissez un nom unique pour la ressource. Pour cet exemple, ncaregistryflex est utilisé.
   Emplacement	Pour cet exemple, sélectionnez la région utilisée pour le groupe de ressources.
   Référence	Sélectionnez Standard.

   Tableau 12.2 Configuration du registre de conteneurs Azure
3. Cliquez sur Vérifier + créer. Notez le nom du registre et le groupe de ressources, car ils seront nécessaires à une étape ultérieure. Cliquez sur Créer. Lorsque le provisionnement est terminé, un message d'état apparaît.
4. Cliquez sur Accéder à la ressource. Notez le nom du registre qui a été fourni dans l'assistant de création. Dans cet exemple, le nom du registre est ncaregistryflex.
5. Générez des clés d'accès pour le registre de conteneurs, qui seront nécessaires plus tard. Pour cet exemple, le registre de conteneurs utilisé est ncaregistryflex. Dans le portail Azure, naviguez vers la ressource de registre de conteneurs. Dans le menu de gauche, sous Paramètres, cliquez sur Clés d'accès. Activez l'utilisateur administrateur.

Conteneuriser le service dorsal

Pour conteneuriser le service dorsal, un Dockerfile doit être créé avec une liste d'instructions pour construire l'image Docker.

1. Naviguez vers le répertoire can-node-express/. Créez un Dockerfile et ajoutez les instructions ci-dessous. Le Dockerfile commence par une image de base pour Node indiquée par l'instruction FROM. Un répertoire de travail est créé et le fichier package.json y est copié. Les dépendances listées dans le fichier package.json sont utilisées pour installer les packages dépendants. Ensuite, le code source de l'application Express.js est copié. Le port 8080 est exposé pour l'application Express.js qui écoute sur ce port. Enfin, la commande pour démarrer le serveur d'application Express.js est ajoutée comme dernière instruction. FROM node:14-alpine # Create app directory WORKDIR /src # Copy package.json and package-lock.json COPY package*.json /src/ # Install npm dependencies ENV NODE_ENV=production RUN npm ci --only=production # Bundle app source COPY ./src EXPOSE 8080 CMD [ "node", "index.js" ]
2. Construisez l'image Docker et poussez-la vers le registre ACR. L'image Docker doit être construite localement et ensuite poussée vers le registre ACR plus tard. Il est supposé qu'un moteur Docker est installé sur l'ordinateur local. Pour construire l'image, exécutez la commande ci-dessous. Notez que la commande a un espace suivi d'un « . » à la fin. Cela fait référence au répertoire actuel et doit faire partie de la commande. Attendez que la construction de l'image Docker soit terminée. docker build -t expressimage .
3. Testez l'application dorsale en exécutant le conteneur Docker. Exécutez la commande suivante. docker run -d --name expressimage -p 8080:8080 expressimage:latest
4. Ouvrez un navigateur et entrez l'URL : http://127.0.0.1:8080/inventory/1.

   

   (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)
5. Balisez l'image afin qu'elle puisse être poussée vers le registre ACR avec la commande ci-dessous. Note : exécutez « docker images » pour confirmer que le nom d'image correct est utilisé pour le balisage Docker. Remplacez <registry_name> par le nom correct du registre ACR. docker tag expressimage:latest <registry_name>.azurecr.io/expressimage:v1

Conteneuriser le service frontal

Pour conteneuriser le service frontal, un Dockerfile doit également être créé avec une liste d'instructions pour construire l'image Docker.

1. Naviguez vers le répertoire can-next/. Créez le Dockerfile et ajoutez les instructions ci-dessous. Le Dockerfile commence par une image de base pour Node indiquée par l'instruction FROM. Un répertoire de travail est créé et le fichier package.json y est copié. Les dépendances listées dans le fichier package.json sont utilisées pour installer les packages dépendants. Ensuite, le code source de l'application Next.js est copié. Le client Prisma est généré. Le port 3000 est exposé car l'application Next.js écoute sur le port 3000. Enfin, la commande pour démarrer le serveur d'application Next.js est ajoutée comme dernière instruction. FROM node:lts-buster-slim AS base RUN apt"-" get update && apt"-" get install libssl"-" dev ca"-" certificates "-" y WORKDIR /app COPY package.json package"-" lock.json ./ FROM base as build RUN export NODE_ENV"=" production RUN yarn COPY . . RUN npx prisma generate RUN yarn build FROM base as prod"-" build RUN yarn install "--" production COPY prisma prisma RUN npx prisma generate RUN cp "-" R node_modules prod_node_modules FROM base as prod COPY "--" from"=" prod"-" build /app/prod_node_modules /app/node_modules COPY "--" from"=" build /app/.next /app/.next COPY "--" from"=" build /app/public /app/public COPY "--" from"=" build /app/prisma /app/prisma EXPOSE 3000 CMD ["yarn","start"
2. Créez le fichier docker-compose.yml et ajoutez le contenu ci-dessous. Cette étape est requise pour que le fichier .env.local soit correctement copié dans le conteneur Docker. services:   web:     ports:       – "3000:3000"     build:       dockerfile: Dockerfile       context: ./     volumes:       – .env.local:/app/.env.local
3. Construisez l'image Docker et poussez-la vers le registre ACR avec cette commande. L'image Docker doit être construite localement et ensuite poussée vers le registre ACR plus tard. Pour construire l'image, exécutez la commande ci-dessous. La commande construira l'image et ensuite exécutera le conteneur. Attendez que l'image soit construite et que le conteneur démarre. docker compose up -d Pour arrêter le conteneur, exécutez la commande docker compose down.
4. Exécutez l'application frontale. Comme docker compose a été utilisé pour le frontal, le conteneur Docker est déjà en cours d'exécution. Ouvrez un navigateur et entrez l'URL http://127.0.0.1:3000.

   

   (rendu à l'aide de Docker ; source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)
5. Étiquetez l'image afin qu'elle puisse être poussée vers le registre ACR avec la commande ci-dessous. Note : exécutez « docker images » pour confirmer que le nom d'image correct est utilisé pour l'étiquetage docker. Remplacez <registry_name> par le nom correct du registre ACR. docker tag cna-next_web:latest <registry_name>.azurecr.io/cna-next_web:v1
6. Poussez les images vers le registre ACR. Tout d'abord, confirmez que les images des applications frontale et dorsale sont correctement étiquetées. Exécutez la commande : « docker images ». Les quatre images suivantes devraient être listées (les images construites à l'origine, puis les images étiquetées pour le registre ACR).

   

   (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)
7. Connectez-vous au registre ACR avec la commande ci-dessous. az acr login --name $REGISTRYNAME Note : l'exécution de la commande ci-dessus suppose que vous êtes connecté au portail Azure. Cela peut être fait avec la commande Azure CLI suivante. az login --scope https://management.core.windows.net//.default
8. Poussez les deux images vers le registre ACR. Exécutez les deux commandes ci-dessous. Remplacez <registry_name> par le nom correct du registre ACR. docker push <registry_name>.azurecr.io/expressimage:v1 docker push <registry_name>.azurecr.io/cna-next_web:v1
9. Dans la console Azure, naviguez jusqu'au registre de conteneurs et cliquez sur le nom du registre, ncaregistryflex. Sous Services, cliquez sur Dépôts. Confirmez que les deux dépôts d'images sont créés. Pour cet exemple, les dépôts sont expressimage et cna-next-web.

Configurer l'environnement

1. La définition de variables d'environnement spécifiques facilite l'exécution des commandes suivantes. Les variables d'environnement doivent être configurées pour le groupe de ressources, la grappe Kubernetes et le registre de conteneurs. Exécutez les commandes suivantes pour définir ces variables. Notez que pour cet exemple, le groupe de ressources utilisé est rg-nativeapps-eastus, le nom de la grappe Kubernetes utilisé est nca-aks, et le nom du registre est ncaregistry. RESOURCEGROUP={resource_group} CLUSTERNAME={cluster_name} REGISTRYNAME={registry_name}
2. La grappe Kubernetes doit pouvoir se connecter au registre ACR pour en extraire les images Docker. Connectez la grappe Kubernetes au registre ACR à l'aide de cette commande. az aks get-credentials --resource-group $RESOURCEGROUP --name $CLUSTERNAME
3. Kubectl est l'outil en ligne de commande Kubernetes utilisé pour gérer les grappes Kubernetes. C'est l'outil qui interagit avec la grappe Kubernetes sur Azure. La première étape pour interagir avec la grappe Kubernetes est de s'y connecter. Exécutez la commande, qui liste les nœuds de la grappe Kubernetes. La sortie liste les nœuds de la grappe. kubectl get nodes
4. L'étape suivante consiste à obtenir le nom d'hôte du registre ACR. Celui-ci est ajouté aux fichiers manifestes de déploiement des microservices afin que les images Docker puissent être extraites du registre et déployées dans la grappe Kubernetes. Exécutez la commande pour interroger le serveur ACR. az acr list --resource-group $RESOURCEGROUP --query "[].{acrLoginServer:loginServer}" --output table

Créer et appliquer les manifestes de déploiement

Les fichiers manifestes de déploiement sont utilisés pour déployer les images Docker des microservices dans la grappe Kubernetes. Ils fournissent des mises à jour déclaratives pour les Pods et ReplicaSets Kubernetes des microservices. Initialement, une seule instance de chaque microservice est rendue disponible. Chaque microservice peut évoluer à la hausse ou à la baisse selon les besoins.

1. Créez un fichier manifeste de déploiement pour l'image Docker, expressimage, pour le service dorsal. Créez le fichier express-deployment.yaml et entrez le contenu suivant. Le manifeste de déploiement déploie le service dorsal avec l'étiquette cna-express. Dans ce fichier manifeste de déploiement, l'image Docker est extraite du registre et est déployée dans un pod de Kubernetes.   # deployment.yaml apiVersion: apps/v1 kind: Deployment metadata:   name: cna-express spec:   selector: # Define the wrapping strategy     matchLabels: # Match all pods with the defined labels       app: cna-express # Labels follow the `name: value` template   template: # This is the template of the pod inside the deployment     metadata:       labels:         app: cna-express     spec:       containers:         - image: ncaregistry.azurecr.io/expressimage           name: expressimage           ports:             - containerPort: 80
2. Appliquez le manifeste de déploiement à la grappe Kubernetes avec la commande suivante. Un message indique que l'objet de déploiement a été créé avec succès. kubectl apply -f ./express-deployment.yaml
3. Créez un fichier manifeste de déploiement pour l'image Docker, webimage, pour le service frontal. Créez le fichier web-deployment.yaml et entrez le contenu suivant. Le manifeste de déploiement déploie le service frontal avec l'étiquette cna-web. Dans ce fichier manifeste de déploiement, l'image Docker est extraite du registre et est déployée dans un pod de Kubernetes. # deployment.yaml apiVersion: apps/v1 kind: Deployment metadata:   name: cna-web spec:   selector: # Define the wrapping strategy     matchLabels: # Match all pods with the defined labels       app: cna-web # Labels follow the `name: value` template   template: # This is the template of the pod inside the deployment     metadata:       labels:         app: cna-web     spec:       containers:         - image: ncaregistry.azurecr.io/webimage           name: webimage           ports:             - containerPort: 80
4. Appliquez le manifeste de déploiement à la grappe Kubernetes avec cette commande. Un message indique que l'objet de déploiement a été créé avec succès. kubectl apply -f ./web-deployment.yaml
5. Confirmez que les déploiements des services dorsal et frontal ont réussi avec les commandes suivantes. Les deux microservices devraient afficher un statut « Running » dans la grappe Kubernetes. kubectl get deploy cna-express kubectl get pods
6. Dans la console Azure, naviguez jusqu'à la page des ressources Kubernetes. Cliquez sur Charges de travail. Les microservices sont déployés avec un statut Prêt.

   

   (Utilisé avec la permission de Microsoft)

Créer et appliquer les manifestes de service

Les deux microservices sont maintenant déployés dans une grappe Kubernetes. Des services Kubernetes sont créés pour chaque microservice afin qu'ils puissent recevoir les requêtes des clients. Kubernetes fournit aux Pods où les microservices sont déployés des adresses IP et un seul nom de domaine entièrement qualifié pour un ensemble de Pods. De plus, les services exposent des ports TCP aux conteneurs où les microservices sont en cours d'exécution.

1. Créez un fichier manifeste de service pour l'image Docker, expressimage, pour le service dorsal. Créez le fichier express-service.yaml et entrez le contenu suivant. Le manifeste de service crée le service Kubernetes pour le service dorsal avec l'étiquette cna-express. #service.yaml apiVersion: v1 kind: Service metadata:   name: cna-express spec:   type: ClusterIP   selector:     app: cna-express   ports:     - port: 8080 # SERVICE exposed port       name: http # SERVICE port name       protocol: TCP # The protocol the SERVICE will listen to       targetPort: 8080
2. Appliquez le manifeste de service à la grappe Kubernetes avec cette commande. Un message indique que l'objet de service a été créé avec succès. kubectl apply -f ./express-service.yaml
3. Créez un fichier manifeste de service pour l'image Docker, webimage, pour le service frontal. Créez le fichier web-service.yaml et entrez le contenu suivant. Le manifeste de service crée le service Kubernetes pour le service web frontal avec l'étiquette cna-web. #service.yaml apiVersion: v1 kind: Service metadata:   name: cna-web spec:   type: ClusterIP   selector:     app: cna-web   ports:     - port: 3000 # SERVICE exposed port       name: http # SERVICE port name       protocol: TCP # The protocol the SERVICE will listen to       targetPort: 3000
4. Appliquez le manifeste de service à la grappe Kubernetes avec cette commande. Un message indique que l'objet de service a été créé avec succès. kubectl apply -f ./web-service.yaml
5. Confirmez que le déploiement du service a réussi. Les services pour chaque microservice devraient être listés. Les adresses IP et les ports devraient également être spécifiés pour chaque microservice. kubectl get service cna-express kubectl get service

Créer et appliquer les contrôleurs d'Ingress

Maintenant que les services sont créés avec des adresses IP attribuées et des ports exposés, les contrôleurs Ingress sont utilisés pour définir comment les microservices déployés sont exposés aux requêtes externes.

1. Tout d'abord, activez la grappe Kubernetes afin qu'elle puisse utiliser le routage d'applications HTTP avec la commande suivante. az aks enable-addons --resource-group $RESOURCEGROUP \ --name $CLUSTERNAME --addons http_application_routing
2. Ensuite, configurez et déployez le contrôleur Ingress. Comme mentionné précédemment, un FQDN est fourni pour un ensemble de Pods de la grappe Kubernetes. Exécutez cette commande pour obtenir ce FQDN. La sortie est le FQDN utilisé pour exposer les microservices aux requêtes externes. az aks show --resource-group $RESOURCEGROUP --name $CLUSTERNAME -o tsv \ --query addonProfiles.httpApplicationRouting.config.HTTPApplicationRoutingZoneName
3. Créez le fichier descripteur Ingress, express-ingress.yaml, pour le service dorsal étiqueté cna-express et ajoutez le contenu suivant. Notez que l'hôte inclut le FQDN qui a été obtenu à l'étape précédente. Il est précédé de cna-express, ce qui le rend unique pour le service dorsal. #ingress.yaml apiVersion: networking.k8s.io/v1 kind: Ingress metadata:   name: cna-express   annotations:     kubernetes.io/ingress.class: addon-http-application-routing spec:   rules:   - host: cna-express.8776bb8bc0324e10946c.eastus.aksapp.io     http:       paths:       - path: / # Which path is this rule referring to         pathType: Prefix         backend: # How the ingress will handle the requests           service:             name: cna-express # Which service the request will be forwarded to             port:               name: http # Which port in that service
4. Appliquez le manifeste Ingress à la grappe Kubernetes avec cette commande. Un message indique que l'objet Ingress a été créé avec succès. kubectl apply -f ./express-ingress.yaml
5. Créez le fichier descripteur Ingress, web-ingress.yaml, pour le service web frontal étiqueté cna-web et ajoutez le contenu suivant. Notez que l'hôte inclut le FQDN qui a été obtenu à l'étape précédente. Il est précédé de cna-web, ce qui le rend unique pour le service web frontal. #ingress.yaml apiVersion: networking.k8s.io/v1 kind: Ingress metadata:   name: cna-web   annotations:     kubernetes.io/ingress.class: addon-http-application-routing spec:   rules:   - host: cna-web.8776bb8bc0324e10946c.eastus.aksapp.io     http:       paths:       - path: / # Which path is this rule referring to         pathType: Prefix         backend: # How the ingress will handle the requests           service:             name: cna-express # Which service the request will be forwarded to             port:               name: http # Which port in that service
6. Appliquez le manifeste Ingress à la grappe Kubernetes avec cette commande. Un message indique que l'objet Ingress a été créé avec succès. kubectl apply -f ./web-ingress.yaml
7. Confirmez que les Ingresses ont été déployés avec succès avec les commandes ci-dessous. Les Ingresses pour les deux microservices afficheront des noms d'hôte uniques pour chaque microservice. kubectl get ingress cna-express kubectl get ingress
8. La commande ci-dessous interroge Azure pour le FQDN qui a été créé précédemment. Il sert de ZoneName. La commande retourne également la valeur ResourceGroup qui est utilisée pour accéder aux microservices. Exécutez la commande ci-dessous et notez les valeurs ZoneName et ResourceGroup. az network dns zone list --output table
9. Substituez les valeurs de ResourceGroup et ZoneName obtenues à l'étape précédente pour <resource-group> et <zone-name>, respectivement, dans la commande qui suit. Exécutez la commande éditée dans le Cloud Shell, ce qui donne le tableau affiché. Deux enregistrements sont ajoutés pour cna-express et deux pour cna-web, qui apparaissent dans la colonne Nom. az network dns record-set list -g <resource-group> -z <zone-name> --output table

   

   (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)
10. Dans un navigateur, accédez au service dorsal en utilisant l'URL générée (par exemple, http://cna-express.8776bb8bc0324e10946c.eastus.aksapp.io/inventory/1), qui inclut la route qui a été implémentée dans le cadre de l'API REST pour le microservice. Le service dorsal reçoit des requêtes au format JSON pour créer et stocker des enregistrements d'inventaire dans le magasin de données. Il récupère également les enregistrements d'inventaire du magasin de données et les rend au format JSON.

    

    (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)
11. Dans un navigateur, accédez au service web frontal en utilisant l'URL générée (par exemple, http://cna-web.8776bb8bc0324e10946c.eastus.aksapp.io). Le service web frontal rend les enregistrements d'inventaire du magasin de données sur une page web.

    

    (rendu à l'aide de Kubernetes ; source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

Créer l'instance EC2

1. AWS Portal est une console web qui permet aux clients de gérer leurs services infonuagiques et leurs abonnements AWS. Dans le portail AWS, recherchez EC2 et cliquez sur Lancer l'instance. Amazon Elastic Compute Cloud (EC2) est une plateforme de calcul basée sur l'infonuage, à la demande, qui peut être mise à l'échelle automatiquement pour répondre à la demande.
2. Sous Images d'application et d'OS, sélectionnez Ubuntu, et laissez les configurations restantes aux paramètres par défaut pour cette section.
3. Sous la section Type d'instance, sélectionnez t2.micro pour le Type d'instance.
4. Sous la section Paire de clés, cliquez sur Créer une nouvelle paire de clés.
5. Entrez une valeur pour Nom de la paire de clés et conservez les paramètres par défaut. Cliquez sur Créer une paire de clés. Le nom utilisé pour cet exemple est cnatanzu-private-key. Téléchargez le fichier cnatanzu-private-key.pem. Ce fichier est utilisé pour se connecter à l'instance EC2. Le nom fourni, cnatanzu-private-key, est renseigné pour le Nom de la paire de clés dans la section Paire de clés.
6. Sous la section Paramètres réseau, sélectionnez Créer un groupe de sécurité. Activez Autoriser le trafic SSH depuis, Autoriser le trafic HTTPS depuis Internet, Autoriser le trafic HTTP depuis Internet. Définissez N'importe où sur 0.0.0.0/0.
7. Sous la section Résumé, cliquez sur Lancer l'instance. Attendez que le provisionnement soit terminé. Un message de succès apparaît avec l'ID de l'instance. Cliquez sur le lien ID de l'instance.
8. Ouvrez un terminal et naviguez vers le répertoire où le fichier cnatanzu-private-key.pem a été téléchargé. Sous le résumé de l'instance, copiez la valeur de DNS IPv4 public. Utilisez la commande pour établir une connexion SSH à l'instance EC2 en insérant le DNS IPv4 public copié. ssh -i nucamp-private-key.pem ubuntu@< EC2 public IPv4 DNS>

Installer Homebrew

Homebrew est un système de gestion de paquets à code source ouvert utilisé pour installer et gérer des paquets sur les systèmes d'exploitation MacOS et Linux. Homebrew, également appelé « brew », est utilisé pour installer Octant plus tard.

1. Homebrew utilise un environnement de compilateur pour construire des paquets qui pourraient avoir besoin d'être construits. La première étape est d'installer un environnement de compilateur avec cette commande. Le paquet build-essentials fournit tous les paquets requis pour l'environnement de compilateur. Exécutez la commande ci-dessous pour installer le paquet build-essentials sudo apt install build-essential
2. Exécutez la commande suivante pour télécharger le script d'installation de brew qui est utilisé pour installer brew. curl -fsSL -o install.sh
3. Exécutez la commande suivante pour lancer le script d'installation. /bin/bash install.sh
4. Une fois le script d'installation terminé, exécutez les deux commandes suivantes pour ajouter brew à la variable d'environnement PATH. Cela rend la commande brew reconnaissable dans l'instance EC2. (echo; echo 'eval \"$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"') >> \ /home/ubuntu/.profile eval \"$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"
5. Confirmez que brew a été ajouté à la variable d'environnement PATH. Tapez la commande brew pour confirmer que le menu d'aide de brew est affiché dans la console. Cela indique que brew a été installé avec succès.

Installer et configurer Docker

Tanzu nécessite que le moteur Docker soit opérationnel. Docker Engine est une plateforme à code source ouvert de conteneurisation (containerization) utilisée pour construire des images Docker et gérer des conteneurs Docker. Pour installer le moteur Docker, Advanced Package Tool (apt) est utilisé. Apt est un outil de gestion de paquets utilisé pour installer de nouveaux paquets et mettre à jour les paquets existants.

1. Exécutez la commande pour mettre à jour l'utilitaire apt lui-même avant d'installer Docker. sudo apt update
2. Exécutez la commande ci-dessous pour installer les paquets suivants comme prérequis pour l'installation de Docker :
   • apt-transport-https, qui permet au gestionnaire de paquets de transférer des fichiers via le protocole HTTPS
   • ca-certificates, qui met à disposition des certificats d'autorité de certification courants pour aider à vérifier la sécurité des connexions
   • curl, qui est utilisé pour transférer des données vers ou depuis un serveur
   • software-properties-common, qui est un paquet pour aider à gérer les installations de logiciels
   sudo apt install apt-transport-https ca-certificates curl software-properties-common
3. Téléchargez un fichier de clé publique de Docker avec la commande ci-dessous. Le fichier de clé publique est ensuite ajouté à une liste de clés de confiance gérées par apt. curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add
4. Exécutez la commande add-apt-repository ci-dessous pour ajouter le dépôt Docker externe à la liste des sources apt. sudo add-apt-repository \"deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable\"" sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable"
5. Après avoir effectué les modifications aux informations du paquet apt lors des étapes précédentes, mettez à jour l'index apt avec cette commande. sudo apt update
6. Exécutez la commande ci-dessous pour installer Docker sur l'instance EC2 : sudo apt install docker-ce
7. Exécutez les trois commandes suivantes pour configurer Docker et installer Docker Compose.
   • Ajoutez l'utilisateur ubuntu actuel au groupe docker. sudo usermod -aG docker ${USER}
   • Téléchargez Docker Compose. Docker Compose est un outil utilisé pour définir, via des fichiers descripteurs, et gérer des applications composées de plusieurs conteneurs Docker. sudo curl -L \ "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$" \ -o /usr/local/bin/docker-compose
   • Exécutez cette commande pour modifier les permissions du fichier docker-compose téléchargé en exécutable afin qu'il puisse être exécuté. sudo chmod +x /usr/local/bin/docker-compose
8. Confirmez que docker et docker-compose ont tous deux été installés. Exécutez ces commandes et confirmez que les versions de docker et docker-compose sont affichées dans la console. docker -v docker-compose -v
9. Exécutez la commande ci-dessous pour démarrer le moteur Docker dans l'instance EC2. sudo systemctl start docker
10. Exécutez la commande ci-dessous pour vérifier si Docker a été installé correctement. sudo docker run hello-world

Installer et configurer Kubectl

Tanzu nécessite kubectl. L'outil de ligne de commande Kubernetes, kubectl, est utilisé pour interagir avec la grappe (cluster) Kubernetes Tanzu.

1. Téléchargez la dernière version de kubectl avec la commande ci-dessous. curl -LO \"https://dl.k8s.io/release/$(curl -L -s \ https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
2. Installez kubectl avec la commande ci-dessous. sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
3. Exécutez les commandes suivantes pour modifier les permissions du fichier kubectl en exécutable afin qu'il puisse être exécuté et copiez-le dans le répertoire ~/.local/bin. chmod +x kubectl mkdir -p ~/.local/bin mv ./kubectl ~/.local/bin/kubectl
4. Ajoutez ~/.local/bin à la variable d'environnement $PATH. Modifiez le fichier ~/.bashrc et ajoutez la ligne suivante à la fin de celui-ci. export PATH=$PATH:~/.local/bin
5. Enregistrez et fermez le fichier. Appliquez les modifications en exécutant la commande suivante : source ~/.bashrc
6. Confirmez, en exécutant la commande kubectl, qu'elle peut être exécutée. Le menu d'aide de kubectl devrait s'afficher dans la console. Cela indique qu'il a été installé avec succès.

Installer Tanzu

1. Installez jq comme paquet de support pour Tanzu avec les commandes suivantes : sudo apt-get update sudo apt-get install jq
2. Installez xdg-utils comme paquet de support pour Tanzu avec la commande suivante : sudo apt-get install --reinstall xdg-utils
3. Assurez-vous que la version de kubectl est compatible avec la version de Tanzu. curl -H \"Accept: application/vnd.github.v3.raw" -L \ https://api.github.com/repos/vmware-tanzu/community-edition/contents/hack/get-tce-release.sh\ | bash -s v0.10.0 linux
4. Décompressez le fichier gzip et installez Tanzu en utilisant le script shell fourni avec la commande ci-dessous. tar xzvf tce-linux-amd64-v0.10.0.tar.gz
5. Naviguez dans le répertoire tce-linux-amd64-v0.10.0/ et exécutez le script shell d'installation avec la commande ci-dessous. /install.sh
6. Confirmez que Tanzu a été installé avec succès. Exécutez la commande tanzu. Le menu d'aide de Tanzu devrait s'afficher dans la console.

Créer les clés secrètes et d'accès AWS requises

Les clés secrètes AWS sont utilisées pour gérer les ressources AWS via l'AWS CLI. AWS CLI est une interface de ligne de commande utilisée pour gérer les services infonuagiques d'Amazon. Les clés d'accès sont utilisées dans la configuration Tanzu pour provisionner et configurer la grappe de gestion Tanzu. Une paire de clés RSA est également utilisée dans la configuration Tanzu pour communiquer avec la grappe de gestion Tanzu.

1. Dans le shell AWS, installez awscli. Tout d'abord, téléchargez le fichier zip de l'AWS CLI avec la commande curl ci-dessous. curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
   • Installez l'utilitaire CLI unzip qui est utilisé pour décompresser le fichier awscliv2.zip téléchargé. Exécutez la commande ci-dessous : sudo apt install unzip
   • Décompressez le fichier awscliv2.zip avec la commande ci-dessous. unzip awscliv2.zip
   • Installez l'AWS CLI décompressé avec la commande ci-dessous. sudo ./aws/install
   • Exécutez la commande ci-dessous pour vérifier que l'AWS CLI a été installé avec succès. La version devrait être affichée. aws - version
2. Dans le portail AWS, sous Gestion des accès, cliquez sur Identifiants de sécurité. Cliquez sur Créer une clé d'accès pour générer la clé. Prenez note des paires de clés car elles seront ajoutées aux paramètres de la grappe de gestion Tanzu.
3. Enfin, générez une paire de clés RSA. Le nom utilisé dans cet exemple est tanzu-key-pair. Prenez note du nom de la paire de clés RSA car il sera ajouté aux paramètres de la grappe de gestion Tanzu. aws ec2 create-key-pair \   --key-name tanzu-key-pair \   --key-type rsa \   --key-format pem \   --query "KeyMaterial" \   --output text > tanzu-key-pair.pem

Créer la configuration de la grappe de gestion Tanzu

Maintenant que l'environnement pour exécuter la grappe de gestion Tanzu est configuré, la prochaine étape est de créer une grappe de gestion Tanzu. Un fichier de configuration de grappe (cluster) de gestion est nécessaire. Une façon de créer un fichier de configuration de grappe de gestion est d'utiliser l'installateur Tanzu, qui est une page web utilisée pour générer le fichier de configuration.14

1. Utilisez l'installateur Tanzu pour créer le fichier de configuration de la grappe de gestion. Lancez la page web de l'installateur Tanzu avec la commande ci-dessous. Une page de navigateur se lance automatiquement. tanzu management-cluster create

   

   (crédit : Tanzu, sous licence publique Mozilla 2.0)
2. Sélectionnez Déployer sur Amazon Web Services. Cela génère un fichier de configuration qui déploie la grappe sur l'instance Amazon EC2 qui a été créée précédemment.
3. Sous la section Fournisseur IaaS, sélectionnez la RÉGION qui est également utilisée comme emplacement pour l'instance EC2.
4. Sous la section Paramètres de la grappe de gestion, assurez-vous que l'hôte Bastion est décoché (désactivé). Pour PAIRE DE CLÉS EC2, entrez le nom de la paire de clés RSA qui a été créée précédemment. Pour cet exemple, le nom utilisé est tanzu-key-pair. Sélectionnez t3a.large pour le TYPE D'INSTANCE DE NŒUD DE TRAVAIL AZ1.
5. Sous la section Gestion des identités, désactivez Activer les paramètres de gestion des identités.
6. Sous la section Image OS, sélectionnez ubuntu-20-04-amd64 comme IMAGE OS.
7. Cliquez sur Revoir la configuration. Tableau 12.4 montre la liste complète des paramètres attendus pour la configuration de la grappe de gestion Tanzu.

   Paramètres du fournisseur IaaS
   Fournisseur IaaS	Valider les identifiants du fournisseur AWS pour Tanzu Community Edition
   PROFIL D'IDENTIFIANT AWS	Par défaut
   RÉGION	us-east-2
   Paramètres VPC pour AWS
   VPC pour AWS	Spécifier les paramètres VPC pour AWS
   CIDR VPC	10.0.0.0/16
   Paramètres de la grappe de gestion
   Paramètres de la grappe de gestion	Grappe de développement sélectionnée : plan de contrôle à 1 nœud
   TYPE D'INSTANCE DE DÉVELOPPEMENT	t3a.large
   NOM DE LA GRAPPE DE GESTION	tkg-cnamgmt-cluster-aws
   PAIRE DE CLÉS EC2	tanzu-key-pair
   ACTIVER LES VÉRIFICATIONS DE SANTÉ DES MACHINES	Oui
   ACTIVER L'HÔTE BASTION	Non
   ACTIVER LA JOURNALISATION D'AUDIT	Non
   AUTOMATISER LA CRÉATION DE LA PILE AWS CLOUDFORMATION	Oui
   ZONE DE DISPONIBILITÉ 1	us-east-2c
   TYPE D'INSTANCE DE NŒUD DE TRAVAIL 1	t3a.large
   TYPE D'INSTANCE DE PRODUCTION
   Paramètres des métadonnées
   Métadonnées	Spécifier les métadonnées pour la grappe de gestion
   EMPLACEMENT
   DESCRIPTION
   ÉTIQUETTES
   Paramètres réseau Kubernetes
   Réseau Kubernetes	CIDR de pod de grappe : 100.96.0.0/11
   FOURNISSEUR CNI	Antrea
   CIDR DE SERVICE DE GRAPPE	100.64.0.0/13
   CIDR DE POD DE GRAPPE	100.96.0.0/11
   ACTIVER LES PARAMÈTRES DE PROXY	Non
   Paramètres de gestion des identités
   Gestion des identités	Spécifier la gestion des identités
   ACTIVER LES PARAMÈTRES DE GESTION DES IDENTITÉS	Non
   Paramètres d'image OS
   Image OS	Image OS : ubuntu-20.04-amd64
   IMAGE OS	ubuntu-20.04-amd64

   Tableau 12.4 Configurations pour Tanzu
8. Copiez la commande CLI générée dans le presse-papiers (ou cliquez sur Déployer la grappe de gestion). Cliquer sur le bouton Déployer la grappe de gestion se connecte à l'instance EC2 et provisionne la grappe de gestion Tanzu. Alternativement, le fichier de configuration qui a été généré est copié dans le répertoire /home/ubuntu/.config/tanzu/tkg/clusterconfigs/. Dans cet exemple, le nom de fichier généré pour le fichier de configuration est kldlaarqyl.yaml. Exécutez la commande copiée dans le shell AWS pour provisionner la grappe de gestion Tanzu.
9. Après l'exécution de la commande copiée, un fichier de configuration, avec « config_ » préfixé comme nom de fichier, est généré et copié dans le répertoire kube-tkg/tmp/.
10. Exécutez la commande ci-dessous pour vérifier l'état de la grappe de gestion Tanzu. Remplacez <config_file> par le nom de fichier généré. Kubectl get \ po.deploy.cluster.kubeadmcontrolplane,machine,machinedeployment\ -A --kubeconfig /home/ubuntu/.kube-tkg/tmp/<config_file>

(source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

Exécuter l'application de démonstration Kuard

Kuard (Kubernetes Up and Running Demo) est une application de démonstration qui fournit des informations sur les environnements Kubernetes en cours d'exécution. L'application de démonstration Kuard est déployée dans la grappe de gestion Tanzu comme une application conteneurisée.

1. Exécutez la commande ci-dessous pour définir le contexte par défaut sur la grappe Tanzu qui vient d'être créée. kubectl config use-context tkg-cnamgmt-cluster-aws-admin@tkg-cnamgmt-cluster-aws
2. Exécutez la commande ci-dessous pour extraire l'image Kuard et démarrer une seule instance d'un Pod Kuard. kubectl run --restart=Never –image=gcr.io/kuar-demo/kuard-amd64:blue kuard
3. Configurez Kuard pour écouter sur le port 8080 et transférer vers le port 8080 dans le pod Kuard. Tout d'abord, exécutez la commande ci-dessous pour lister le Pod et noter le nom du Pod. Le nom du Pod devrait être kuard et devrait être opérationnel. kubectl get pods
4. Exécutez la commande ci-dessous pour utiliser le transfert de port et exposer le port par défaut de Kuard, 8080. kubectl port forward kuard 8080:8080
5. Lancez le site web Kuard dans le navigateur en utilisant l'URL http://localhost:8080.

(crédit : Kubernetes, sous licence publique Mozilla 2.0)

Installer et exécuter Octant

Octant est une interface web à code source ouvert pour Kubernetes qui est utilisée pour inspecter les grappes Kubernetes et les applications qui y sont déployées.

1. Exécutez la commande ci-dessous pour installer Octant en utilisant Homebrew. brew install octant
2. Lancez Octant en tapant la commande octant dans le shell AWS. Une fenêtre de navigateur se lance automatiquement.

(crédit : Octant, un projet soutenu par VMware)

Configurer le stockage pour la fonction consommatrice

1. Exécutez les commandes ci-dessous pour créer les chaînes de caractères de connexion utilisées pour accéder au compte de stockage du hub d'événements. AZURE_WEB_JOBS_STORAGE=$(\ az storage account show-connection-string\   --resource-group $RESOURCE_GROUP\   --name $STORAGE_ACCOUNT"p"\   --query connectionString\   --output tsv) EVENT HUB_CONNECTION_STRING=$(\ az eventhubs eventhub authorization-rule keys list\   --resource-group $RESOURCE_GROUP\   --name $EVENT_HUB_AUTHORIZATION_RULE\   --eventhub-name $EVENT_HUB_NAME\   --namespace-name $EVENT_HUB_NAMESPACE\   --query primaryConnectionString\   --output tsv)
2. Exécutez les commandes ci-dessous pour obtenir les chaînes de caractères de connexion qui ont été créées à l'étape précédente. Prenez note de ces chaînes de caractères de connexion car elles seront utilisées plus tard. echo $AZURE_WEB_JOBS_STORAGE echo $EVENT_HUB_CONNECTION_STRING
3. Les chaînes de caractères de connexion qui ont été générées pour le stockage Azure Web Jobs et le hub d'événements à l'étape précédente doivent être ajoutées en tant que paramètres d'application au compte d'application de fonction Azure dans la commande. Exécutez la commande ci-dessous avec ces valeurs insérées pour créer l'application de fonction. Une notification à la console indique que l'application de fonction a été construite avec succès. az functionapp config appsettings set\   --resource-group $RESOURCE_GROUP\   --name $FUNCTION_APP"-p" \   --settings\ AzureWebJobsStorage=$AZURE_WEB_JOBS_STORAGE\ EventHubConnectionString=$EVENT_HUB_CONNECTION_STRING

Construire et déployer la fonction productrice FaaS

Maintenant que les Azure ressources, telles que le hub d'événements, l'application de fonction Azure et le compte de stockage, ont été créées et configurées, l'étape suivante consiste à créer un projet de fonction FaaS Azure pour la fonction productrice FaaS. Maven est utilisé pour construire le projet.

1. Exécutez la commande ci-dessous pour créer et construire le projet de fonction. Le répertoire telemetry-functions-producer/ est généré avec les fichiers du projet. Un message "Build Success" indiquant que la construction a réussi devrait apparaître dans la console. mvn archetype:generate -batch-mode\   -DarchetypeGroupid=com.microsoft.azure\   -Darchetype ArtifactId=azure-functions-archetype\   -DappName=$FUNCTION_APP"-p"\   -DresourceGroup=$RESOURCE_GROUP\   -DappRegion=$LOCATION\   -DappServicePlanName=$LOCATION"plan" \   -Dgroupid=com.learn\   -DartifactId=telemetry-functions-producer
2. Exécutez la commande ci-dessous pour ajouter les paramètres d'application de la fonction Azure dans le fichier local.settings.json du projet de fonction situé dans le répertoire racine telemetry-functions-producer/. func azure functionapp fetch-app-settings $FUNCTION_APP”-p”
3. Naviguez vers le répertoire telemetry-functions-producer/src/main/java/com/learn/. Modifiez le fichier Function.java et remplacez tout le code qu'il contient par le code suivant. Le code déclare une fonction qui établit une connexion au hub d'événements Azure. package com.learn; import com.microsoft.azure.functions.annotation.EventHubOutput; import com.microsoft.azure.functions.annotation.FunctionName; import com.microsoft.azure.functions.annotation.TimerTrigger; import com.microsoft.azure.functions.ExecutionContext; public class Function {   @FunctionName("generatesSensorData")   @EventHubOutput(   name = "event",   eventHubName = "", // vide car la valeur est incluse dans la chaîne de caractères de connexion   connection = "EventHub ConnectionString")   public Telemetryltem generateSensorData(   @TimerTrigger(   name = "timerInfo",   schedule = "*/10*****") // toutes les 10 secondes   String timerInfo,   final ExecutionContext context) {     context.getLogger().info("Java Timer trigger function executed at: "+java.time.LocalDateTime.now()); double temperature = Math.random()* 100;     double pressure = Math.random() * 50;     return new Telemetryltem;   } }
4. Créez un fichier nommé TelemetryItem.java et ajoutez le code ci-dessous. Le code déclare des éléments de données simulés qui sont poussés vers le hub d'événements Azure. package com.learn; public class TelemetryItem {   private String id;   private double temperature;   private double pressure;   private boolean isNormalPressure;   private status temperatureStatus;   static enum status {     COOL,     WARM,     HOT   } public TelemetryItem(double temperature, double pressure) {     this.temperature = temperature;     this.pressure = pressure;   }   public String getId() {     return id;   }   public double getTemperature() {     return temperature;   }   public double getPressure() {     return pressure;   }   @Override   public String toString() {     return "TelemetryItem={ id=" + id + ",temperature=" + temperature + ",pressure= " + pressure + "}";   }   public boolean isNormalPressure() {     return isNormalPressure;   }   public void setNormalPressure(boolean isNormal) {     this.isNormalPressure = isNormal;   }   public status getTemperatureStatus() {     return temperatureStatus;   }   public void setTemperatureStatus {     this.temperatureStatus = temperatureStatus;   } }
5. Dans le répertoire telemetry-functions-producer/, exécutez la commande ci-dessous pour construire la fonction. Un message "Build Success" apparaît dans la console indiquant que la construction a réussi. mvn clean package
6. Exécutez la commande ci-dessous pour tester la fonction et confirmer qu'elle s'exécute correctement. La sortie affichée indique que la fonction s'exécute correctement. Mvn azure-functions:run

   

   (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)
7. Exécutez la commande ci-dessous pour déployer la fonction productrice FaaS en tant qu'application de fonction Azure. Une fois le déploiement terminé, les URL de déclenchement HTTP sont fournies. mvn azure-functions:deploy

Construire et déployer la fonction consommatrice FaaS

Maintenant que les ressources Azure, telles que le hub d'événements, l'application de fonction Azure, le compte de stockage et Azure Cosmos DB, ont été créées et configurées, l'étape suivante consiste à créer un projet de fonction FaaS Azure pour la fonction productrice FaaS. Maven est utilisé pour construire le projet.

1. Exécutez la commande ci-dessous pour créer le projet de fonction pour la fonction consommatrice FaaS. Le répertoire telemetry-functions-consumer/ est généré avec les fichiers du projet. mvn archetype:generate -batch-mode\   -DarchetypeGroupId=com.microsoft.azure   -DarchetypeArtifactId=azure-functions-archetype   -DappName=$FUNCTION_APP"-c" \   -DresourceGroup=$RESOURCE_GROUP   -DappRegion=$LOCATION\   -DappServicePlanName=$LOCATION"plan" \   -Dgroupid=com.learn \   -DartifactId=telemetry-functions-consumer
2. Naviguez dans le répertoire telemetry-functions-consumer/. Exécutez la commande ci-dessous pour mettre à jour les paramètres locaux pour l'exécution locale avec la commande. Ces paramètres sont ajoutés au fichier local.settings.json. func azure functionapp fetch -app-settings \ $FUNCTION_APP”-p”
3. Naviguez vers le répertoire src/main/java/com/learn/. Remplacez tout le code de Function.java par le code ci-dessous. Le code déclare une fonction qui établit des connexions au hub d'événements Azure et à Azure Cosmos DB. package com.learn; import com.learn.TelemetryItem.status; import com.microsoft.azure.functions.annotation.FunctionName; import com.microsoft.azure.functions.ExecutionContext; import com.microsoft.azure.functions.OutputBinding; import com.microsoft.azure.functions.annotation.Cardinality; import com.microsoft.azure.functions.annotation.CosmosDBOutput; import com.microsoft.azure.functions.annotation.EventHubTrigger; public class Function {   @FunctionName("processSensorData")   public void processSensorData(   @EventHubTrigger(   name ="msg",   eventHubName = "", // vide car la valeur est incluse dans la chaîne de caractères de connexion   cardinality = Cardinality.ONE,   connection = "EventHubConnectionString")   TelemetryItem item,   @CosmosDBOutput(   name = "databaseOutput",   databaseName ="TelemetryDb",   collectionName ="TelemetryInfo",   connectionStringSetting = "Cosmos DB ConnectionString")   OutputBinding <TelemetryItem> document,   final ExecutionContext context) {     context.getLogger().info("Event hub message received: " + item.toString());     if (item.getPressure() > 30) {       item.setNormalPressure(false);     }     else {       item.setNormalPressure(true);     }     if (item.getTemperature() < 40) {       item.setTemperatureStatus(status.COOL);     }     else if (item.getTemperature() > 90) {       item.setTemperatureStatus(status.HOT);     }     else {       item.setTemperatureStatus(status.WARM);     }     document.setValue;   }
4. Créez le fichier TelemetryItem.java et ajoutez le code ci-dessous. Le code déclare des éléments de données qui sont reçus du bus d'événements Azure et stockés dans la base de données Azure Cosmos DB. package com.learn; public class TelemetryItem {     private String id;     private double temperature;     private double pressure;     private boolean isNormalPressure;     private status temperatureStatus;     static enum status {         COOL,         WARM,"         HOT     }     public TelemetryItem {         this.temperature = temperature;         this.pressure = pressure;     }     public String getId() {         return id;     }     public double getTemperature() {         return temperature;     }     public double getPressure() {         return pressure;     }     @Override"     public String toString() {         return \"TelemetryItem={id=" + id + \",temperature="             + temperature + ",pressure=" + pressure + "}";     }     public boolean isNormalPressure() {         return isNormalPressure;     }     public void setNormalPressure {         this.isNormalPressure = isNormal;     }     public status getTemperatureStatus() {         return temperatureStatus;     }     public void setTemperatureStatus {         this.temperatureStatus = temperatureStatus;     } }
5. Naviguez vers le répertoire telemetry-functions-consumer/ et construisez la fonction avec la commande ci-dessous. Une fois la construction terminée, un message "Build Success" s'affiche dans la console pour indiquer que la construction a réussi. mvn clean package
6. Exécutez la commande ci-dessous pour vérifier si la fonction s'exécute correctement. mvn azure-functions:run
7. Comme mentionné précédemment, la fonction consommatrice FaaS écoute les événements d'un espace de noms spécifique dans le hub d'événements Azure et les traite et les stocke dans une base de données Azure Cosmos DB. Les événements stockés dans la base de données Azure Cosmos DB peuvent être vérifiés en visitant la page Azure Cosmos DB dans le portail Azure. Dans le portail Azure, naviguez vers la page Azure Cosmos DB. Dans le menu de gauche, cliquez sur "Data Explorer", cliquez sur l'onglet "TelemetryInfo", puis cliquez sur "Items" développé à partir de "TelemetryInfo" pour afficher les données. Les données continueront d'être envoyées à la base de données Azure Cosmos DB, qui peut être consultée en temps réel.
8. Exécutez la commande ci-dessous pour déployer les fonctions vers Azure Functions. Une fois le déploiement terminé, un message "Build Success" apparaît dans la console. mvn azure-functions:deploy

Évaluer la fonction productrice FaaS

La première étape consiste à inspecter la carte d'application pour les deux fonctions FaaS. Les cartes d'application représentent la structure logique d'une application distribuée. Les composants individuels de l'application sont identifiés par leur propriété "roleName" et sont déployés indépendamment. Ces composants sont représentés par des cercles, appelés "nœuds" sur la carte. Les appels HTTP entre les nœuds sont représentés par des flèches reliant le nœud source au nœud cible. Les cartes d'application aident à identifier les goulots d'étranglement de performance ou les points chauds de défaillance à travers tous les composants via des alertes.

La carte d'application (Figure 12.41) affiche la structure logique de la fonction productrice FaaS et du bus d'événements Azure. Elle montre la fonction productrice FaaS comme un nœud connecté à un hub d'événements Azure, également comme un nœud. La carte d'application pour la fonction productrice FaaS montre qu'il existe une dépendance entre la fonction productrice FaaS et le hub d'événements Azure. Elle montre également que la fonction productrice FaaS n'est pas dépendante de la fonction consommatrice FaaS ni de la base de données Azure Cosmos DB.

Figure 12.41 Cette carte d'application montre la fonction productrice FaaS comme un nœud connecté à un hub d'événements Azure, également comme un nœud. (Utilisé avec la permission de Microsoft)

La carte d'application présentée dans Figure 12.42 affiche la structure logique de la fonction consommatrice FaaS et de la base de données Azure Cosmos DB. Elle montre la fonction consommatrice FaaS comme un nœud connecté à une base de données Azure Cosmos DB, également comme un nœud. La carte d'application pour la fonction consommatrice FaaS montre qu'il existe une dépendance entre la fonction consommatrice FaaS et la base de données Azure Cosmos DB. Elle montre également que la fonction consommatrice FaaS n'est pas dépendante de la fonction productrice FaaS ni du hub d'événements Azure.

Figure 12.42 Cette carte d'application montre la fonction consommatrice FaaS comme un nœud connecté à une base de données Azure Cosmos DB, également comme un nœud. (Utilisé avec la permission de Microsoft)