Comment déployer une application ASP.NET Core avec MySQL Server à l’aide de Nginx sur Ubuntu 18.04

L’auteur a sélectionné la Open Source Initiative pour recevoir un don dans le cadre de la Write for DOnations programme.

introduction

ASP.NET Core est un framework hautement performant et open-source permettant de créer des applications Web modernes, conçu pour être une version plus modulaire. ASP.NET Framework de Microsoft. Sorti en 2016, il peut fonctionner sur plusieurs systèmes d’exploitation tels que Linux et macOS. Cela permet aux développeurs de cibler un système d’exploitation particulier pour le développement en fonction des exigences de conception. Avec ASP.NET Core, un développeur peut créer tout type d’application ou de service Web, quelles que soient leur complexité et leur taille. Les développeurs peuvent également utiliser les Razor pages pour créer des travaux de conception centrés sur la page. au-dessus du modèle traditionnel Model-View-Controller (MVC).

ASP.NET Core offre la souplesse nécessaire pour s’intégrer à n’importe quel framework frontal afin de gérer la logique côté client ou de consommer un service Web. Vous pouvez, par exemple, créer une API RESTful avec ASP.NET Core et la consommer facilement avec des infrastructures JavaScript telles que Angular, React et Vue.js.

Dans ce didacticiel, vous allez configurer et déployer une application ASP.NET Core prête pour la production avec un serveur MySQL sur Ubuntu 18.04 à l’aide de Nginx. Vous déploierez une application ASP.NET Core démo similaire à celle de la documentation de Microsoft et hébergée sur https://github.com/aspnet/AspNetCore.Docs/tree/master/aspnetcore/tutorials/razor-pages/razor-pages-. start / 2.2-stage-samples [GitHub]. Une fois déployée, l’application de démonstration vous permettra de créer une liste de films et de la stocker dans la base de données. Vous pourrez créer, lire, mettre à jour et supprimer des enregistrements de la base de données. Vous pouvez utiliser ce tutoriel pour déployer votre propre application ASP.NET Core. Il est possible que vous deviez implémenter des étapes supplémentaires, notamment la génération d’un nouveau fichier de migration pour votre base de données.

Conditions préalables

Vous aurez besoin des éléments suivants pour ce tutoriel:

Étape 1 - Installation de .NET Core Runtime

Un environnement d’exécution .NET Core est requis pour exécuter avec succès une application .NET Core. Vous devez donc commencer par l’installer sur votre ordinateur. Tout d’abord, vous devez enregistrer le référentiel de clé Microsoft et de produit. Après cela, vous installerez les dépendances requises.

Tout d’abord, connectez-vous en tant que votre nouvel utilisateur créé, assurez-vous d’être dans votre répertoire racine:

cd ~

Ensuite, exécutez la commande suivante pour enregistrer le référentiel de clé et de produit Microsoft:

wget -q https://packages.microsoft.com/config/ubuntu/18.04/packages-microsoft-prod.deb

Utilisez + dpkg + avec l’indicateur + -i + pour installer le fichier spécifié:

sudo dpkg -i packages-microsoft-prod.deb

Pour faciliter l’installation des autres packages requis pour votre application, vous installerez le référentiel + universe + avec la commande suivante:

sudo add-apt-repository universe

Ensuite, installez le paquetage + apt-transport pour permettre l’utilisation de référentiels accessibles via le protocole HTTP Secure:

sudo apt install apt-transport-https

Maintenant, exécutez la commande suivante pour télécharger la liste des packages à partir des référentiels et mettez-les à jour pour obtenir des informations sur les versions les plus récentes des packages et leurs dépendances:

sudo apt update

Enfin, vous pouvez installer le SDK d’exécution .NET avec:

sudo apt install dotnet-sdk-2.2

Vous serez invité avec les détails de la taille des fichiers supplémentaires qui seront installés. Tapez + A + et appuyez sur + ENTER pour continuer.

Maintenant que vous avez terminé d’installer le Kit de développement logiciel .NET Core runtime sur le serveur, vous êtes presque prêt à télécharger l’application de démonstration à partir de GitHub et à configurer la configuration de déploiement. Mais d’abord, vous allez créer la base de données pour l’application.

Étape 2 - Création d’un utilisateur MySQL et d’une base de données

Dans cette section, vous allez créer un utilisateur du serveur MySQL, créer une base de données pour l’application et octroyer tous les privilèges nécessaires au nouvel utilisateur pour lui permettre de se connecter à la base de données à partir de votre application.

Pour commencer, vous devez accéder au client MySQL en utilisant le compte racine MySQL, comme indiqué ici:

mysql -u root -p

Vous serez invité à saisir le mot de passe du compte root, défini lors du didacticiel préalable.

Ensuite, créez une base de données MySQL pour l’application avec:

CREATE DATABASE ;

Vous verrez la sortie suivante dans la console:

OutputQuery OK, 1 row affected (0.03 sec)

Vous avez maintenant créé la base de données avec succès. Ensuite, vous allez créer un nouvel utilisateur MySQL, les associer à la base de données nouvellement créée et leur octroyer tous les privilèges.

Exécutez la commande suivante pour créer l’utilisateur et le mot de passe MySQL. N’oubliez pas de changer le nom d’utilisateur et le mot de passe pour quelque chose de plus sécurisé:

CREATE USER ''@'localhost' IDENTIFIED BY '';

Vous verrez la sortie suivante:

OutputQuery OK, 0 rows affected (0.02 sec)

Pour accéder à une base de données ou effectuer une action spécifique sur celle-ci, un utilisateur de MySQL a besoin de l’autorisation appropriée. À l’heure actuelle, * movie-admin * ne dispose pas de l’autorisation appropriée sur la base de données de l’application.

Vous allez changer cela en exécutant la commande suivante pour accorder l’accès à * movie-admin * sur ++:

GRANT ALL PRIVILEGES ON .* TO ''@'localhost';

Vous verrez la sortie suivante:

OutputQuery OK, 0 rows affected (0.01 sec)

Maintenant, vous pouvez recharger les tables d’attribution en exécutant la commande suivante pour appliquer les modifications que vous venez de faire à l’aide de l’instruction flush:

FLUSH PRIVILEGES;

Vous verrez la sortie suivante:

OutputQuery OK, 0 rows affected (0.00 sec)

Vous avez terminé de créer un nouvel utilisateur et d’accorder des privilèges. Pour vérifier si vous êtes sur la bonne voie, quittez le client MySQL:

quit;

Reconnectez-vous à l’aide des informations d’identification de l’utilisateur MySQL que vous venez de créer et entrez le mot de passe approprié à l’invite:

mysql -u  -p

Vérifiez que l’utilisateur * movie-admin * peut accéder à la base de données créée, vérifiez avec:

SHOW DATABASES;

Vous verrez la table ++ listée dans le résultat:

Output+--------------------+
| Database           |
+--------------------+
|          |
| information_schema |
+--------------------+
2 rows in set (0.01 sec)

Maintenant, quittez le client MySQL:

quit;

Vous avez créé une base de données, créé un nouvel utilisateur MySQL pour l’application de démonstration et accordé à l’utilisateur nouvellement créé les privilèges nécessaires pour accéder à la base de données. Dans la section suivante, vous allez commencer à configurer l’application de démonstration.

Étape 3 - Configuration de l’application de démonstration et des informations d’identification de la base de données

Comme indiqué précédemment, vous déploierez une application ASP.NET Core existante. Cette application a été conçue pour créer une liste de films et utilise le modèle de conception Modèle-Vue-Contrôleur pour assurer une structure et une séparation appropriées des problèmes. Pour créer ou ajouter un nouveau film à la liste, l’utilisateur remplira les champs du formulaire avec les détails appropriés, puis cliquez sur le bouton * Créer * pour envoyer les détails au contrôleur. À ce stade, le contrôleur recevra une requête HTTP POST contenant les détails soumis et conservera les données dans la base de données via le modèle.

Vous utiliserez Git pour extraire le code source de cette application de démonstration à partir de GitHub et l’enregistrer dans un nouveau répertoire. Vous pouvez également télécharger une autre application ici si vous déployez une autre application.

Pour commencer, créez un nouveau répertoire nommé ++ à partir du terminal en utilisant la commande suivante:

sudo mkdir -p /var/www/

Cela servira de répertoire racine pour votre application. Ensuite, changez le propriétaire et le groupe du dossier afin de permettre à un compte utilisateur non root de travailler avec les fichiers du projet:

sudo chown : /var/www/

Remplacez * sammy * par votre nom d’utilisateur sudo non root.

Maintenant, vous pouvez vous déplacer dans le répertoire parent et cloner l’application sur GitHub:

cd /var/www
git clone https://github.com/do-community/movie-app-list.git

Vous verrez la sortie suivante:

OutputCloning into ''...
remote: Enumerating objects: 91, done.
remote: Counting objects: 100% (91/91), done.
remote: Compressing objects: 100% (73/73), done.
remote: Total 91 (delta 13), reused 91 (delta 13), pack-reused 0
Unpacking objects: 100% (91/91), done.

Vous avez cloné avec succès l’application de démonstration à partir de GitHub. La prochaine étape consiste donc à créer une connexion avec succès à la base de données de l’application. Pour ce faire, éditez la propriété + ConnectionString dans le fichier` + appsettings.json` et ajoutez les détails de la base de données.

Changer de répertoire dans l’application:

cd

Ouvrez maintenant le fichier pour le modifier:

sudo nano appsettings.json

Ajoutez vos identifiants de base de données:

appsettings.json

{
 "Logging": {
   "LogLevel": {
     "Default": "Warning"
   }
 },
 "AllowedHosts": "*",
 "ConnectionStrings": {
   "MovieContext": "Server=localhost;User Id=;Password=;Database="
 }
}

Avec cela en place, vous avez créé avec succès une connexion à votre base de données. Maintenant, appuyez sur + CTRL + X + pour enregistrer vos modifications dans le fichier et tapez + Y + pour confirmer. Appuyez ensuite sur + ENTER pour quitter la page.

Les applications ASP.NET Core utilisent une bibliothèque standard .NET nommée Entity Framework (EF) Core pour gérer les interactions avec la base de données. Entity Framework Core est une version légère multiplate-forme de la technologie d’accès aux données Entity Framework, très répandue. Il s’agit d’un ORM (Object-Relational Mapper) qui permet aux développeurs .NET de travailler avec une base de données en utilisant l’un des fournisseurs de base de données, tels que MySQL.

Vous pouvez maintenant mettre à jour votre base de données avec les tables de l’application de démonstration clonée. Exécutez la commande suivante à cette fin:

dotnet ef database update

Cela appliquera une mise à jour à la base de données et créera les schémas appropriés.

Maintenant, pour construire le projet et toutes ses dépendances, exécutez la commande suivante:

dotnet build

Vous verrez une sortie similaire à:

OutputMicrosoft (R) Build Engine version 16.1.76+g14b0a930a7 for .NET Core
Copyright (C) Microsoft Corporation. All rights reserved.

 Restore completed in 95.09 ms for /var/www//MvcMovie.csproj.
 MvcMovie -> /var/www//bin/Debug/netcoreapp2.2/MvcMovie.dll
 MvcMovie -> /var/www//bin/Debug/netcoreapp2.2/MvcMovie.Views.dll

Build succeeded.
   0 Warning(s)
   0 Error(s)

Time Elapsed 00:00:01.91

Ceci construira le projet et installera toutes les dépendances tierces répertoriées dans le fichier ++ mais l’application ne sera pas encore prête pour la production. Pour que l’application soit prête à être déployée, exécutez la commande suivante:

dotnet publish

Vous verrez ce qui suit:

OutputMicrosoft (R) Build Engine version 16.1.76+g14b0a930a7 for .NET Core
Copyright (C) Microsoft Corporation. All rights reserved.

Restore completed in 89.62 ms for /var/www/movie-app/MvcMovie.csproj.
MvcMovie -> /var/www//bin/Debug/netcoreapp2.2/MvcMovie.dll
MvcMovie -> /var/www//bin/Debug/netcoreapp2.2/MvcMovie.Views.dll
MvcMovie -> /var/www//bin/Debug/netcoreapp2.2/publish/

Cela compresse et compile l’application, lit ses dépendances, publie le jeu de fichiers résultant dans un dossier à déployer et produit un fichier multiplate-forme + .dll + qui utilise le runtime .NET Core installé pour exécuter l’application.

En installant des dépendances, en créant une connexion à la base de données, en mettant à jour la base de données avec les tables nécessaires et en la publiant pour la production, vous avez terminé la configuration de cette application de démonstration. Dans l’étape suivante, vous allez configurer le serveur Web pour rendre l’application accessible et sécurisée sur votre domaine.

Étape 4 - Configuration du serveur Web

À présent, après avoir suivi les Comment sécuriser Nginx avec Let’s Tutoriel de chiffrement, vous aurez un bloc serveur pour votre domaine à + ​​/ etc / nginx / sites-available / + avec la directive ++ déjà définie de manière appropriée. Dans cette étape, vous allez éditer ce bloc de serveur pour configurer Nginx en tant que proxy inverse pour votre application. Un proxy inverse est un serveur situé devant des serveurs Web et qui transmet la demande de chaque navigateur Web à ces serveurs Web. Il reçoit toutes les demandes du réseau et les transmet à un autre serveur Web.

Dans le cas d’une application ASP.NET Core, Kestrel est le serveur Web préféré qui est inclus avec par défaut. Il est idéal pour la fourniture de contenu dynamique à partir d’une application ASP.NET Core, car il offre de meilleures performances de traitement des demandes et a été conçu pour rendre ASP.NET aussi rapide que possible. Toutefois, Kestrel n’est pas considéré comme un serveur Web complet car il ne peut pas gérer la sécurité et servir des fichiers statiques. C’est pourquoi il est conseillé de toujours l’exécuter derrière un serveur Web.

Pour commencer, assurez-vous que vous vous trouvez dans le répertoire racine de votre serveur:

cd ~

Ouvrez le bloc serveur pour édition avec:

sudo nano /etc/nginx/sites-available/

Comme indiqué en détail dans https://www.digitalocean.com/community/tutorials/how-to-secure-nginx-with-let-s-encrypt-on-ubuntu-18-04#step-4-%E2%80 % 94-obtenir-un-certificat-ssl [étape 4] de la https://www.digitalocean.com/community/tutorials/how-to-secure-nginx-with-let-s-encrypt-on-ubuntu- 18-04 [Comment sécuriser Nginx avec le tutoriel Let’s Encrypt], si vous avez sélectionné l’option 2, Certbot configurera automatiquement ce bloc de serveur afin de rediriger le trafic HTTP vers HTTPS en apportant quelques modifications.

Continuez la configuration en modifiant les deux premiers blocs du fichier pour refléter les éléments suivants:

/ etc / nginx / sites-available / votre-domaine

server {

   server_name   www.;

  location / {
    proxy_pass http://localhost:5000;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection keep-alive;
    proxy_set_header Host $host;
    proxy_cache_bypass $http_upgrade;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
   }

listen [::]:443 ssl ipv6only=on; # managed by Certbot
listen 443 ssl; # managed by Certbot
ssl_certificate /etc/letsencrypt/live//fullchain.pem; # managed by Certbot
ssl_certificate_key /etc/letsencrypt/live//privkey.pem; # managed by Certbot
include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot


}
...

La configuration de ce bloc serveur ordonnera à Nginx d’écouter sur le port + 443 +, qui est le port standard pour les sites Web qui utilisent SSL. De plus, Nginx acceptera le trafic public sur le port + 443 + et transmettra chaque requête correspondante au serveur Kestrel intégré à + ​​http: // localhost: 5000 +.

Enfin, après le bloc de serveur que vous venez de modifier dans le fichier, assurez-vous que le deuxième bloc de serveur ressemble à ceci:

/ etc / nginx / sites-available / votre-domaine

...
server {
if ($host = www.) {
   return 301 https://$host$request_uri;
} # managed by Certbot


if ($host = ) {
   return 301 https://$host$request_uri;
} # managed by Certbot


   listen 80;
   listen [::]:80;

   server_name   www.;
return 404; # managed by Certbot
}

Ce bloc serveur redirige toutes les demandes vers + https: // + et + https: // www. + Vers un accès HTTPS sécurisé.

Ensuite, forcez Nginx à prendre en compte les modifications apportées au bloc serveur en exécutant:

sudo nginx -s reload

Une fois la configuration de Nginx effectuée avec succès, le serveur est entièrement configuré pour transférer toutes les requêtes HTTPS effectuées vers + https: // + vers l’application ASP.NET Core s’exécutant sur Kestrel à l’adresse + http: // localhost: 5000+. `. Cependant, Nginx n’est pas configuré pour gérer le processus du serveur Kestrel. Pour gérer cela et vous assurer que le processus Kestrel continue de s’exécuter en arrière-plan, vous utiliserez les fonctionnalités `+ systemd +.

Les fichiers Systemd vous permettront de gérer un processus en fournissant des fonctionnalités de démarrage, d’arrêt, de redémarrage et de journalisation une fois que vous avez créé. un processus de travail appelé une unité.

Déplacez-vous dans le répertoire + systemd +:

cd /etc/systemd/systems

Créez un nouveau fichier pour le modifier:

sudo nano

Ajoutez-y le contenu suivant:

movie.service

[Unit]
Description=

[Service]
WorkingDirectory=/var/www/
ExecStart=/usr/bin/dotnet /var/www//bin/Debug/netcoreapp2.2/publish/MvcMovie.dll
Restart=always
RestartSec=10
SyslogIdentifier=
User=
Environment=ASPNETCORE_ENVIRONMENT=Production
Environment=DOTNET_PRINT_TELEMETRY_MESSAGE=false

[Install]
WantedBy=multi-user.target

Le fichier de configuration spécifie l’emplacement du dossier du projet avec + WorkingDirectory + et la commande à exécuter au début du processus dans + ExecStart +. De plus, vous avez utilisé la directive + RestartSec + pour indiquer quand redémarrer le service + systemd + si le service d’exécution .NET se bloque.

Enregistrez maintenant le fichier et activez le nouveau service de film créé avec:

sudo systemctl enable

Ensuite, démarrez le service et vérifiez qu’il fonctionne en lançant le service:

sudo systemctl start

Puis vérifiez son statut:

sudo systemctl status

Vous verrez la sortie suivante:

Output -
  Loaded: loaded (/etc/systemd/system/; enabled; vendor preset: enabled)
  Active: active (running) since Sun 2019-06-23 04:51:28 UTC; 11s ago
Main PID: 6038 (dotnet)
   Tasks: 16 (limit: 1152)
  CGroup: /system.slice/
          └─6038 /usr/bin/dotnet /var/www//bin/Debug/netcoreapp2.2/publish/MvcMovie.dll

Cette sortie vous donne un aperçu du statut actuel du ++ créé pour que votre application continue à fonctionner. Cela indique que le service est activé et actuellement actif.

Accédez à + ​​https: // + à partir de votre navigateur pour exécuter et tester l’application.

Vous verrez la page d’accueil de l’application de démonstration- * Application de liste de films *.

image: https: //i.imgur.com/VI7KTaU.png [Application de liste de films]

Avec le proxy inverse configuré et géré par Kestrel via systemd, l’application Web est entièrement configurée et est accessible à partir d’un navigateur.

Conclusion

Dans ce didacticiel, vous avez déployé une application ASP.NET Core sur un serveur Ubuntu. Pour conserver et gérer les données, vous avez installé et utilisé le serveur MySQL et utilisé le serveur Web Nginx en tant que proxy inverse pour servir votre application.

Au-delà de ce didacticiel, si vous souhaitez créer une application Web interactive utilisant C # au lieu de Javascript, vous pouvez essayer un framework d’interface Web de Microsoft appelé https://dotnet.microsoft.com/apps/aspnet/web-apps/client [ Blazor]. Il s’agit d’une interface utilisateur Web basée sur les composants et basée sur les événements pour l’implémentation de la logique côté client d’une application ASP.NET Core.

Si vous souhaitez déployer votre propre application, vous devrez envisager d’autres procédures requises pour déployer votre application. Le code source complet de cette application de démonstration peut être trouvé à l’adresse here sur GitHub.