Création d'une application Go avec Docker sur AWS : création d'une interface RESTful pour l'ajout et la récupération d'éléments

Présentation

Alors que la plupart des applications Go sont compilées dans un seul fichier binaire, les applications Web sont également livrées avec des modèles, des ressources et des fichiers de configuration ; ceux-ci peuvent se désynchroniser et provoquer des déploiements erronés.
Docker nous permet de créer une image autonome avec tout ce dont notre application a besoin pour fonctionner. Dans cet article, nous apprendrons comment déployer une application Web Go à l'aide de Docker installé sur une instance, et comment Docker peut vous aider à améliorer votre flux de travail de développement et votre processus de déploiement.

Les étapes dont nous avons besoin seront les suivantes :

- Lancez une instance (votre machine) pour construire Docker sur et en déplacement
candidature
- Installer Docker en instance
- Installer Go en instance
- Créez des fichiers de code pour votre application Go
- Tests d'applications

Lancez une instance (votre machine) pour créer Docker et c'est parti
candidature

Vous pouvez retrouver les mêmes étapes de lancement et de connexion d'instance décrites dans l'article :

https://dev.to/zahraajawad/building-a-jupyter-notebook-environment-in-docker-for-data-analysis-on-aws-ec2-376i

Remarque : Assurez-vous de choisir le groupe de sécurité :

• SSH-Port 22 : Pour accéder et se connecter à l'instance en utilisant SSH
  protocole pour gérer le système à distance.

• HTTP-Port 8080 : Pour exécuter l'application Go sur ce port (8080) afin d'y accéder depuis Internet ou le réseau local, ce port doit être ouvert.

- Installer Docker dans notre instance

L'architecture de flux de travail spécifique que nous allons créer utilise Docker pour fournir un environnement de flux de travail intégré.
Ainsi, après vous être connecté à l'instance via SSH et obtenu le privilège root, utilisez l'automatisation de commande suivante pour installer Docker :

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - && sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" && sudo apt-get update && apt- politique de cache docker-ce

Expérience Docker : Exécutez une simple commande de test docker -v pour vérifier que Docker fonctionne correctement et voir la version de Docker :

Installation de Go

Vous pouvez installer Go en le téléchargeant depuis le site officiel de Go https://go.dev/dl/
wget https://golang.org/dl/go1.20.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.20.linux-amd64.tar.gz
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bash_profile
source ~/.bash_profile

où :
wget https://golang.org/dl/go1.20.linux-amd64.tar.gz consiste à télécharger le binaire Go.

et
sudo tar -C /usr/local -xzf go1.20.linux-amd64.tar.gz consiste à extraire l'archive tar dans /usr/local.
et
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bash_profile pour mettre à jour la variable d'environnement PATH.
et source ~/.bash_profile pour appliquer les modifications apportées au profil

Donc, après avoir exécuté les commandes et vérifié l'exécution via la commande ls pour afficher les fichiers téléchargés :

Initialisez l'application Go avec le code suivant :
aller mod init my-go-app

Maintenant, nous devons créer un dossier de projet par la commande :
mkdir
Changez ensuite le répertoire courant par la commande :
cd
donc l'exécution est :

Créez des fichiers de code pour votre application Go

Le fichier main.go

Nous créons un nouveau fichier appelé main.go qui contient les fonctions et codes suivants que nous expliquerons en détail puis nous mettons tous les codes dans le fichier main.go :

• Pour importer les packages nécessaires, nous utilisons le code :

import (
    "encoding/json"
    "log"
    "net/http"
    "github.com/gorilla/mux"
    "os"
)

• Pour l'élément de structure de données :

type Item struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

où itemest une structure de données contenant un identifiant (ID) et un nom (Name). Ces champs sont convertis au format JSON à l'aide de balises (json:"id" et json:"name".

• variable d'éléments

var items []Item

qui est une tranche d'éléments stockés dans la mémoire du serveur.

• Grâce à la fonction principale, les structures sont organisées en lisant le port (ici ce sera sur le port 8080) en plus d'orienter les différentes requêtes depuis la récupération ou l'ajout d'un nouvel élément et l'affichage d'une simple page HTML.

import (
    "encoding/json"
    "log"
    "net/http"
    "github.com/gorilla/mux"
    "os"
)

• La fonction getItems renvoie une liste d'éléments au format JSON. Le type de contenu dans l'en-tête est défini sur application/json.

type Item struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

• La fonction createItem ajoute un nouvel élément à la liste des éléments. Les données sont lues à partir du corps de la demande au format JSON, l'élément se voit attribuer un ID en fonction du nombre d'éléments existants et l'élément ajouté est renvoyé au format JSON.

var items []Item

• La fonction serveHome affiche une simple page HTML avec un message de bienvenue (Bienvenue dans l'application Go) et des liens pour accéder aux données.

func main() {
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    router := mux.NewRouter()
    router.HandleFunc("/items", getItems).Methods("GET")
    router.HandleFunc("/items", createItem).Methods("POST")
    router.HandleFunc("/", serveHome).Methods("GET")

    log.Printf("Server is running on port %s...\n", port)
    log.Fatal(http.ListenAndServe(":"+port, router))
}

Donc, l'intégralité du fichier main.go est :

func getItems(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(items)
}

Maintenant, via la commande vim ou nano, créez le fichier main.go et mettez le code ci-dessus dans le fichier, ici nous utiliserons la commande nano :

nano main.go

Et passé les codes :

puis quittez le fichier depuis le clavier par ctrl x puis y (pour enregistrer le fichier) puis cliquez sur enter

Fichier Docker :

Est un document texte qui contient toutes les commandes qu'un utilisateur peut appeler sur la ligne de commande pour assembler une image.
Dockerfile peut créer des images automatiquement en lisant les instructions d'un Dockerfile.

Créer un fichier Docker :

Un Dockerfile avec des instructions de construction est requis pour créer une image de conteneur avec Docker.
Nous créons un Dockerfile et ajoutons le code suivant de la même manière que précédemment via la commande nano Dockerfile :

Les détails de la commande Dockerfile peuvent être trouvés sur la page d'accueil de Docker Docs https://docs.docker.com/guides/golang/build-images/

Maintenant que nous avons préparé le Dockerfile, il est temps de créer une image Docker pour l'application Go. L'image peut être réalisée à partir des images Docker officielles qui sont :

docker build -t my-go-app .

L'image est construite avec succès, et pour vous assurer de la construction en utilisant la commande :
images du menu fixe

Ensuite, pour exécuter le conteneur après avoir construit l'image, nous utilisons :

docker run -p 8080:8080 my-go-app

où 8080 est le port des serveurs web, donc le run d'exécution est :

Tests d'applications

- Testez l'application Go par la commande curl

Pour tester si l'application Go fonctionne correctement via la commande curl en :

boucle http://localhost:8080/items

ou

curl http://:8080/items

l'exécution est null, ce qui signifie que l'application fonctionne mais que nous n'avons pas encore de données.

Pour ajouter un élément, par la commande :

curl -X POST -H "Content-Type : application/json" -d '{"name": "item"}' http://localhost:8080/items

ou

curl -X POST -H "Content-Type: application/json" -d '{"name": "item"}' http://:8080/items

donc l'exécution de l'ajout :

on peut ajouter un autre article :

- Testez l'application Go par la page web

Pour tester si l'application Go fonctionne correctement via la page Web, suivez les étapes suivantes :

• Retournez à l'instance et sélectionnez-la par la case à cocher.
• Allez dans les détails et copiez l'adresse IPv4 publique.
• Collez l'adresse IPv4 publique avec le port 8080 dans le navigateur et appuyez sur Entrez.

La page web fonctionne et quand on appuie sur éléments sur la page on obtient les éléments qui s'ajoutent par la commande curl.

Ou vous pouvez appuyer sur la case à cocher de Pretty-print :

Références :

• https://dev.to/zahraajawad/building-a-jupyter-notebook-environment-in-docker-for-data-analysis-on-aws-ec2-376i
• https://semaphoreci.com/community/tutorials/how-to-deploy-a-go-web-application-with-docker
• https://hub.docker.com/_/golang
• https://docs.docker.com/guides/golang/build-images/
• https://github.com/gorilla/mux

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!