Conteneurisez vos applications Rust avec Docker pour simplifier le déploiement et assurer la cohérence entre différents environnements.

La conteneurisation offre des avantages essentiels en termes de portabilité, d'isolement et d'efficacité. Il permet un déploiement cohérent des applications dans divers environnements et garantit la sécurité et la stabilité grâce à l'isolation des applications. Il optimise également l'utilisation des ressources, simplifie les processus de développement et de gestion et améliore l'évolutivité.

La conteneurisation des applications Rust avec Docker fournit un moyen fiable et efficace de regrouper les applications et leurs dépendances dans des environnements autonomes et portables. Il permet une exécution transparente sur divers systèmes sans se soucier de l'infrastructure sous-jacente.

Configurer un serveur Web simple en Rust avec Actix

Tu peux configurer un serveur Web simple dans Rust avec Actix et conteneurisez votre application avec Docker. Vous exposerez un port à partir duquel vous accéderez au serveur pour les demandes.

instagram viewer

Exécutez cette commande pour créer un nouveau projet Rust avec le Gestionnaire de colis de fret:

cargo nouveau mon-application

Lorsque vous créez un nouveau projet Rust, Cargo ajoute le cargo.toml fichier dans le répertoire racine de votre projet. Ouvrez le cargo.toml déposer et ajouter la caisse Actix au dépendances section comme suit :

[dépendances]
actix-web = "4.3.1"

Voici comment configurer un serveur simple dans Rust avec la caisse Actix :

utiliser actix_web ::{get, App, HttpResponse, HttpServer, Responder} ;
// Importation des dépendances nécessaires depuis le framework Web Actix


#[obtenir("/")]
asynchronefnBonjour() -> mettre en œuvre Répondant {
// Définit une fonction de gestionnaire pour les requêtes GET vers le chemin racine ("/")
// La fonction retourne un type qui implémente le trait Responder


 HttpResponse ::D'accord().corps("Bonjour le monde!")
// Renvoie une réponse HTTP avec un code d'état de 200 (OK)
// et un corps de réponse de "Hello, World!"
}


#[actix_web:: principal]
asynchronefnprincipal() -> std:: io ::Résultat {
// Point d'entrée de l'application


 ServeurHttp:: nouveau(|| {
// Crée une nouvelle instance du HttpServer


 App:: new().service (bonjour)
// Créer une nouvelle instance de l'application et enregistrer la fonction hello 
 }).lier("127.0.0.1:8080")?.courir().attendre
// Associez le serveur à l'adresse IP et au port
// Démarre le serveur et attend sa fin
}

Le programme met en place un serveur Web HTTP de base avec Actix. Le Bonjour la fonction est une fonction de gestionnaire qui répond aux requêtes GET sur le port 8080 avec "Hello, World!".

Le principal la fonction configure une instance de serveur avec la HttpServer:: nouveau fonction et lie le serveur pour qu'il s'exécute sur l'adresse localhost 127.0.0.1:8080.

Maintenant, exécutez le course de fret commande pour exécuter le serveur Web. Voici le résultat de l'ouverture de l'adresse sur un navigateur Web.

Écrire un Dockerfile pour votre application Rust

Pour conteneuriser votre application Rust avec Docker, vous devez créer un Fichier Docker et définir les commandes pour le processus de conteneurisation.

Le Fichier Docker n'a pas d'extension; il vous suffit de créer un Fichier Docker déposer. Vous pouvez également créer un .dockerignore file pour extraire les fichiers de votre répertoire de travail de votre processus de construction.

Définir des commandes dans votre Dockerfile

Ton Fichier Docker contiendra des commandes qui extraient une image de base du référentiel Docker, définissent le répertoire de travail, copient le fichiers, créer des dépendances, créer l'application, créer une image minimale, exporter le port et exécuter le application.

# Utilisez la dernière version de l'image de base de Rust
DEPUIS rouille: dernière
# Définissez le répertoire de travail dans le conteneur sur /my
RÉP TRAVAIL /usr/src/my-app


# Copiez les fichiers du projet Rust dans le répertoire de travail
COPIE. .


# Construire l'application Rust
COURIR construction de cargaison
# Définissez la commande pour exécuter l'application Rust
CMD course de fret

Après avoir défini les commandes requises pour conteneuriser votre application, vous pouvez créer un conteneur avec cette commande :

docker build -t mon-application .

La commande crée une image Docker pour votre mon-application application avec la balise mon-application du répertoire courant.

Vous pouvez utiliser le course de docker commande pour exécuter votre image Docker.

docker run -p 8080:8080 mon-application

Le -p 8080:8080 mappe le port 8080 de la machine hôte sur le port 8080 du conteneur. Docker transmettra le trafic dirigé vers le port 8080 de la machine hôte vers le port 8080 du conteneur.

Vous pouvez envoyer des demandes au conteneur via le port localhost 8080 pour appeler le serveur Web.

Docker Compose permet l'orchestration multi-conteneurs

Travailler avec plusieurs conteneurs est une tâche courante lors de la création d'applications Docker sophistiquées. Vous pouvez utiliser Docker Compose pour travailler avec plusieurs conteneurs Docker.

Docker Compose fournit des fonctionnalités pour définir les services qui composent votre application, en spécifiant les dépendances entre les services, définir les variables d'environnement pour chaque service, démarrer, arrêter, redémarrer, mettre à l'échelle les conteneurs de votre application, etc. fonctionnalités.