Containeriseer uw Rust-applicaties met Docker om de implementatie te vereenvoudigen en consistentie in verschillende omgevingen te garanderen.

Containerisatie biedt essentiële voordelen op het gebied van draagbaarheid, isolatie en efficiëntie. Het maakt consistente implementatie van applicaties in verschillende omgevingen mogelijk en zorgt voor beveiliging en stabiliteit door applicatie-isolatie. Het optimaliseert ook het gebruik van bronnen, vereenvoudigt ontwikkelings- en beheerprocessen en verbetert de schaalbaarheid.

Het containeriseren van Rust-apps met Docker biedt een betrouwbare en efficiënte manier om applicaties en hun afhankelijkheden te verpakken in zelfstandige en draagbare omgevingen. Het maakt een naadloze uitvoering over verschillende systemen mogelijk zonder dat u zich zorgen hoeft te maken over de onderliggende infrastructuur.

Een eenvoudige webserver opzetten in Rust met Actix

Jij kan een eenvoudige webserver opzetten in Rust met Actix en containeriseer uw app met Docker. U stelt een poort bloot van waaruit u toegang krijgt tot de server voor verzoeken.

instagram viewer

Voer deze opdracht uit om een ​​nieuw Rust-project te maken met de Beheerder vrachtvervoer:

cargo nieuwe mijn-app

Wanneer u een nieuw Rust-project maakt, voegt Cargo het vracht.toml bestand naar de hoofdmap van uw project. Open de vracht.toml bestand en voeg de Actix-krat toe aan het afhankelijkheden sectie als volgt:

[afhankelijkheden]
actix-web = "4.3.1"

Zo kun je een eenvoudige server opzetten in Rust met de Actix-krat:

gebruik actix_web::{get, App, HttpResponse, HttpServer, Responder};
// Importeer noodzakelijke afhankelijkheden uit het Actix Web-framework


#[krijgen("/")]
asynchroonfnHallo() -> impl Antwoorder {
// Definieer een handlerfunctie voor GET-verzoeken naar het rootpad ("/")
// De functie retourneert een type dat de eigenschap Responder implementeert


 Http-antwoord::OK().lichaam("Hallo Wereld!")
// Retourneer een HTTP-antwoord met een statuscode van 200 (OK)
// en een antwoordtekst van "Hello, World!"
}


#[actix_web:: hoofd]
asynchroonfnvoornaamst() -> standaard:: io::Resultaat {
// Ingangspunt van de applicatie


 HttpServer:: nieuw(|| {
// Maak een nieuw exemplaar van de HttpServer


 App:: new().service (hallo)
// Maak een nieuwe instantie van de app en registreer de hallo-functie 
 }).binden("127.0.0.1:8080")?.loop().wachten
// Bind de server aan het IP-adres en de poort
// Start de server en wacht op voltooiing
}

Het programma zet een standaard HTTP-webserver op met Actix. De Hallo functie is een handlerfunctie die reageert op GET-verzoeken op poort 8080 met "Hallo, Wereld!".

De voornaamst functie stelt een serverinstantie in met de HttpServer:: nieuw functie en bindt de server om op localhost-adres te draaien 127.0.0.1:8080.

Voer nu de vracht rennen opdracht om de webserver uit te voeren. Dit is het resultaat van het openen van het adres in een webbrowser.

Een Dockerfile schrijven voor uw Rust-app

Om uw Rust-app te containeriseren met Docker, moet u een Dockerfile en definieer de opdrachten voor het containerisatieproces.

De Dockerfile heeft geen extensie; je hoeft alleen maar een Dockerfile bestand. U kunt ook een .dockerignore bestand om bestanden in uw werkmap uit uw bouwproces te abstraheren.

Commando's definiëren in uw Dockerfile

Jouw Dockerfile zal opdrachten bevatten die een basisafbeelding uit de Docker-repository halen, de werkmap instellen, het bestanden, bouw afhankelijkheden, bouw de applicatie, maak een minimale image, exporteer de port en voer het sollicitatie.

# Gebruik de nieuwste versie van de Rust-basisafbeelding
VAN roest: laatste
# Stel de werkdirectory in de container in op /my
WERKDIR /usr/src/my-app


# Kopieer de Rust-projectbestanden naar de werkmap
KOPIËREN. .


# Bouw de Rust-app
LOOP vracht bouwen
# Stel de opdracht in om de Rust-app uit te voeren
CMD vracht rennen

Nadat u de vereiste opdrachten voor het containeriseren van uw app hebt gedefinieerd, kunt u een container bouwen met deze opdracht:

docker build -t mijn-app .

De opdracht bouwt een Docker-image voor uw mijn-app app met de tag mijn-app uit de huidige map.

U kunt de havenarbeider rennen opdracht om uw Docker-image uit te voeren.

docker run -p 8080:8080 mijn app

De -p 8080:8080 optie wijst poort 8080 van de hostcomputer toe aan poort 8080 van de container. Docker zal het verkeer dat naar poort 8080 op de hostmachine wordt geleid, doorsturen naar poort 8080 in de container.

U kunt verzoeken naar de container sturen via localhost-poort 8080 om de webserver aan te roepen.

Docker Compose maakt orkestratie met meerdere containers mogelijk

Werken met meerdere containers is een veelvoorkomende taak bij het bouwen van geavanceerde Docker-applicaties. U kunt Docker Compose gebruiken om met meerdere Docker-containers te werken.

Docker Compose biedt functionaliteit voor het definiëren van de services waaruit uw app bestaat, het specificeren van de afhankelijkheden tussen services, het definiëren van de omgevingsvariabelen voor elke service, het starten, stoppen, herstarten, het schalen van de containers van uw applicatie en andere functionaliteiten.