Jusqu'à ce que les débutants de Docker déploient des microservices délirants créés en Python sur Fargate

Aperçu

Cet article décrit la création d'une application de type microservice avec Python, MySQL et Docker et son déploiement sur Fargate.

Je voulais utiliser Fargate, qui est considéré comme le plus populaire (en partie) sur AWS, et j'étais intéressé par l'architecture des microservices. Cependant, comme je n'ai jamais traité correctement des micro-services, c'est une architecture délirante que "je me demande si ça ressemble à ça". Si vous avez des erreurs, nous vous serions reconnaissants de bien vouloir nous donner votre avis.

De plus, AWS a RDS, mais comme le conteneur est également un débutant, j'utilise également le conteneur MySQL pour étudier.

Que sont les microservices et Fargate en premier lieu?

Il existe de nombreuses explications sur le net, mais je vais brièvement décrire ma compréhension.

Micro service

• L'application se compose de __ petits services, chacun faiblement couplé __. ――En raison d'un couplage desserré, la réparation est effectuée dans chaque service. ―― Étant donné que chaque service peut être développé par plusieurs équipes, chaque équipe peut utiliser le langage et le cadre dans lesquels elle est douée. (Au contraire, il peut être unifié pour l'ensemble de l'application) --Le ** container ** est utilisé comme technologie pour réaliser un petit service. --Kubernetes et AWS ECS sont des outils de gestion des conteneurs. --Dans la communication de données entre les services, ** REST et gRPC ** sont principalement utilisés. La technologie de messagerie (telle que Kafka) peut également être utilisée.

Fargate

• Pour être exact, utilisez-le en combinaison avec ECS et EKS.
• Vous pouvez gérer le conteneur à l'aide d'un outil d'orchestration de conteneur tel qu'ECS, mais vous devez gérer l'hôte (serveur) sur lequel le conteneur est déployé séparément. Par exemple, si le conteneur évolue et que la charge sur l'hôte augmente, l'hôte doit également évoluer, ce qui est très difficile pour l'utilisateur d'une telle gestion. --Fargate est un service de type gestion ** dans lequel AWS gère cet hôte **. La mise à l'échelle donnée dans l'exemple étant également effectuée automatiquement, ** les utilisateurs n'ont pas besoin de connaître la gestion des hôtes **.

Telle est la compréhension. En d'autres termes, cette fois, j'essaierai de déployer le micro service construit avec __Docker sur Fargate, qui est le service de gestion d'AWS __.

Image de l'application

--Il existe deux micro-services, Apl et BackEnd.

• La communication entre les services est HTTP (REST)
• Accédez à l'API du service Apl depuis le client. Image d'accès du client à la base de données en accédant à l'API du service BackEnd à partir du service Apl «La raison pour laquelle Python est divisé en 3.6 et 3.8 est que je voulais juste faire l'expérience que" Docker peut le faire ", et il n'y a pas d'autre raison. Il n'y a aucun problème avec les deux 3.6.

Structure de l'article et objectifs

Commencez par déployer le microservice localement en tant qu'hôte, puis apportez-le à Fargate. Après un déploiement réussi sur Fargate, l'objectif est de pouvoir communiquer avec les deux microservices de l'extérieur via HTTP.

environnement

• Environnement de développement
• Python 3.6 / 3.8
• MySQL 5.7
• Docker
• Mac OS
• Connaissances préalables --Lire la source Python
• Connaissances de base sur SQL
• J'ai utilisé docker-compose
• Vous pouvez en quelque sorte comprendre à quoi ressemble le nom du service AWS

1. Commencez par utiliser Mac comme hôte

Déployez l'application sur votre Mac local. Les sources, etc. sont les suivantes.

Structure des dossiers

Créez des dossiers pour chacun des trois conteneurs (apl-service, db-service, mysql).

.
├── apl-service
│   ├── Dockerfile
│   └── src
│       ├── results.py
│       └── server.py
├── db-service
│   ├── Dockerfile
│   └── src
│       ├── server.py
│       └── students.py
├── docker-compose.yml
└── mysql
    ├── Dockerfile
    └── db
        ├── mysql_data
        └── mysql_init
            └── setup.sql

Lié à MySQL

mysql/Dockerfile

FROM mysql/mysql-server:5.7

RUN chown -R mysql /var/lib/mysql && \
    chgrp -R mysql /var/lib/mysql

setup.sql et les données réellement enregistrées

create table students (id varchar(4), name varchar(20), score int);
insert into students values ('1001', 'Alice', 60);
insert into students values ('1002', 'Bob', 80);
commit;
mysql> select * from DB01.students;
+------+-------+-------+
| id   | name  | score |
+------+-------+-------+
| 1001 | Alice |    60 |
| 1002 | Bob   |    80 |
+------+-------+-------+

lié au service db

db-service/Dockerfile

FROM python:3.6

#Travailler DIR sur le conteneur
WORKDIR /usr/src/

#Installation de la bibliothèque
RUN pip install flask mysql-connector-python

CMD python ./server.py

db-service/src/server.py

from flask import Flask, request, abort, render_template, send_from_directory
from students import get_students

app = Flask(__name__)


@app.route('/students', methods=['GET'])
def local_endpoint():
    return get_students()


if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5001)

db-service/src/students.py

import json
import mysql.connector as mydb


def get_students():
    conn = mydb.connect(user="user", passwd="password",
                        host="mysql", port="3306")

    cur = conn.cursor()
    sql_qry = 'select id, name, score from DB01.students;'
    cur.execute(sql_qry)

    rows = cur.fetchall()

    results = [{"id": i[0], "name": i[1], "score": i[2]} for i in rows]
    return_json = json.dumps({"students": results})
    cur.close()
    conn.close()

    return return_json

• Explication facile de la source
• Exécutez server.py lors du démarrage du conteneur Docker. --server.py utilise Flask pour configurer un serveur. C'est une API qui retourne le résultat en exécutant get_students importé de student.py lorsque la ressource / Students``` est accédée par GET. --get_students se connecte au conteneur MySQL et stocke les résultats sélectionnés dans la base de données en lignes. À partir des lignes, il est converti en dict en notation d'inclusion, puis converti en json et la valeur est renvoyée.
• Pour un déploiement local, vous pouvez bien vous connecter entre les conteneurs sans utiliser de links. Ou plutôt, links semble être une vieille technique qui n'a pas été utilisée très récemment ...

lié au service apl

apl-service/Dockerfile

FROM python:3.8

#Travailler DIR sur le conteneur
WORKDIR /usr/src/

#Installation de la bibliothèque
RUN pip install requests flask

CMD python ./server.py

apl-service/src/server.py

from flask import Flask, request, abort, render_template, send_from_directory
from results import get_results

API_URI = 'http://db-service:5001/students'

app = Flask(__name__)


@app.route('/results', methods=['GET'])
def local_endpoint():
    return get_results(API_URI)


if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5002)

apl-service/src/results.py

import json
import requests


def get_results(uri):
    r = requests.get(uri)
    students = r.json()["students"]
    return_students = []
    for student in students:
        if student["score"] > 70:
            student.setdefault("isPassed", True)
            return_students.append(student)
        else:
            student.setdefault("isPassed", False)
            return_students.append(student)

    return_json = json.dumps({"addedStudents": return_students})

    return return_json

• Explication facile de la source
• Le server.py est presque le même que db-service. C'est une API qui renvoie le résultat en exécutant get_results importé de results.py lorsque la ressource / results``` est accédée par GET.
• La différence est que l'URI est défini pour accéder à l'API du service db à partir de get_results. --get_results stocke la valeur obtenue à partir de db-serive chez les étudiants. Tournez ceci avec for et définissez " isPassed " sur True si la valeur de chaque score est supérieure à 70, False sinon, et ajoutez l'élément json.

docker-compose

docker-compose.yml

version: '3'

services:
  mysql:
    container_name: mysql
    build:
      context: .
      dockerfile: ./mysql/Dockerfile
    hostname: mysql
    ports:
      - "3306:3306"
    volumes:
      - ./mysql/db/mysql_init:/docker-entrypoint-initdb.d
      - ./mysql/db/mysql_data:/var/lib/mysql
    environment:
      MYSQL_USER: user
      MYSQL_PASSWORD: password
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: DB01
    command: mysqld --character-set-server=utf8 --collation-server=utf8_unicode_ci --skip-character-set-client-handshake
 
  db-service:
    build:
      context: .
      dockerfile: ./db-service/Dockerfile
    container_name: db-service
    ports:
      - "5001:5001"
    volumes:
      - ./db-service/src/:/usr/src/

  apl-service:
    build:
      context: .
      dockerfile: ./apl-service/Dockerfile
    container_name: apl-service
    ports:
      - "5002:5002"
    volumes:
      - ./apl-service/src/:/usr/src/

• Explication facile de la source
• Dans les volumes mysql, docker-entrypoint-initdb.d est configuré pour stocker le fichier setup.sql précédent. Dans MySQL, le SQL sous docker-entrypoint-initdb.d est exécuté au premier démarrage. Bref, ce sont les données initiales.

Déployer et exécuter

Je vais omettre le résultat, mais le déployer avec la commande docker-compose.

build&up

$ docker-compose build
$ docker-compose up

Une fois le déploiement réussi, essayez d'accéder à chaque microservice via HTTP pour confirmer la communication. Comme vous pouvez le voir à partir de la source, db-service utilise les ports 5001 et apl-service utilise les ports 5002.

db-Service d'accès

$ curl http://127.0.0.1:5001/students
{"students": [{"id": "1001", "name": "Alice", "score": 60}, {"id": "1002", "name": "Bob", "score": 80}]}

apl-Service d'accès

$ curl http://127.0.0.1:5002/results
{"addedStudents": [{"id": "1001", "name": "Alice", "score": 60, "isPassed": false}, {"id": "1002", "name": "Bob", "score": 80, "isPassed": true}]}

Vous avez maintenant déployé avec succès le microservice sous-jacent (délirant) localement. Étant donné que le résultat de l'API du service apl est renvoyé, vous pouvez également confirmer qu'il existe une communication entre les microservices apl-service et db-service.

Je vais apporter ça à Fargate tout de suite! Mais cela faisait longtemps d'ici ...

2. Image de la version finale à nouveau

Il s'agit d'un diagramme de configuration de la version finale basée sur le déploiement sur Fargate.

Les points sont les suivants.

―― 1 Déploiement de microservices sur un Fargate. --Il y a une communication entre les conteneurs (db-service ⇔ mysql) dans la tâche. --Il y a communication inter-tâches (service apl ⇔ service db).

Sur cette base, nous allons déployer.

3. Inscrivez-vous avec ECR

Tout d'abord, poussez les trois images docker créées (service apl, service db, mysql) vers ECR. L'interface utilisateur d'ECR est facile à comprendre, donc si vous appuyez sur «Créer un référentiel» à partir de la console AWS et que vous procédez tel quel, vous pouvez le pousser.

• Veuillez arrêter le conteneur démarré créé en 1 et lancer docker rm.

4. Avant de déployer sur Fargate

Avec ECS, vous pouvez utiliser docker-compose.yml. Après avoir défini ecs-cli, suivez le tutoriel ci-dessous pour déployer sur Fargate, mais vous devez modifier docker-compose.yml etc. Je vais soulever divers points de correction, mais la source de la version finale est publiée à la fin de l'article, donc si vous êtes occupé, veuillez vous y référer.

Tutoriel: Créer un cluster de tâches Fargate à l'aide de l'interface de ligne de commande Amazon ECS

De plus, dans cette application, nous utilisons également les ports 5001, 5002, nous devons donc les autoriser dans les paramètres du groupe de sécurité à l'étape 3.

Lors de l'autorisation de 5001

$ aws ec2 authorize-security-group-ingress --group-id <security-group-id> --protocol tcp --port 5001 --cidr 0.0.0.0/0 --region <region>

Split docker-compose.yml

• Cette fois, nous déploierons deux microservices en deux tâches. Pour cette raison, docker-compose.yml doit également être divisé en deux. Vous devez également exécuter la commande deploy deux fois. --Split par backend (db-service, mysql) et apl (apl-service).
• Vous aurez deux fichiers docker-compose.yml avec le même nom, donc séparez les dossiers de manière appropriée.

Exemple) Dossier "aws_Stocker dans "travail" et déployer avec le backend de nom de tâche

$ pwd
/Users/<réduction>/aws_work
$ ls docker-compose.yml   # db-service +docker mysql-compose.yml
docker-compose.yml
$ ecs-cli compose --project-name backend service up ~

Exemple) Dossier "aws_Stocker dans "travail" et déployer avec le nom de tâche apl

$ pwd
/Users/<réduction>/aws_work2
$ ls docker-compose.yml   # apl-service docker-compose.yml
docker-compose.yml
$ ecs-cli compose --project-name apl service up ~

• À ce stade, le déploiement ne fonctionnera pas.

Spécification de l'image poussée vers ECR

• Spécifiez l'image que vous avez poussée plus tôt au lieu du Dockerfile. Puisque build, container_name et hostname ne sont pas obligatoires, spécifiez ʻimage` à la place.
• Dans l'exemple ci-dessous, le nom du référentiel ECR pour le conteneur mysql est python-mysql / mysql. --Remplacez également db-service et apl-service par ʻimage`.

Exemple) docker-compose.points de correction yml(paramètres d'image)

  mysql:
    image: <aws_account_id>.dkr.ecr.<region>.amazonaws.com/python-mysql/mysql

Correction de ne pas utiliser de volumes

--Fargate ne prend pas en charge les volumes de stockage persistants. Cela semble difficile, mais cela signifie que vous ne pouvez pas utiliser de volumes dans docker-compose.yml. Par conséquent, la source telle que server.py n'est pas reflétée dans le conteneur. --Ainsi, commentez (ou supprimez physiquement) les volumes de docker-compose.yml et modifiez chacun d'eux pour inclure COPY dans le Dockerfile. --db-service et apl-service apportent des modifications similaires.

• Depuis que j'ai modifié le Dockerfile, je dois le pousser à nouveau vers ECR.

Exemple) docker-compose.points de correction yml

    # volumes:
    #   - ./db-service/src/:/usr/src/

Exemple) db-service/Points de modification du Dockerfile

#Copiez la source dans le conteneur
COPY ./src/server.py /usr/src/server.py 
COPY ./src/students.py /usr/src/students.py 

Paramètres du journal du conteneur

• Comme mentionné dans le didacticiel ci-dessus, configurez la journalisation des conteneurs en tant que meilleure pratique pour les tâches Fargate. Ici, le nom du groupe de journaux est python-docker.
• Définissez la même chose pour db-service et apl-service.

Exemple) docker-compose.points de correction yml(Journal du conteneur)

  mysql:
    logging:
      driver: awslogs
      options: 
        awslogs-group: python-docker
        awslogs-region: <region>
        awslogs-stream-prefix: mysql

Notez également que, bien que non résolu cette fois, Fargate exige que les ports aient le même numéro sur les côtés hôte et conteneur. Par exemple, vous pouvez spécifier «80: 5001» localement, mais vous obtiendrez une erreur si vous ne spécifiez pas «5001: 5001» dans Fargate.

J'ai fixé environ 4 points, mais cela ne fonctionne toujours pas.

5. Modifiez davantage et déployez vers Fargate

5-1. Communication inter-conteneurs et communication inter-tâches

À partir de là, il s'agit d'une modification nécessaire pour réaliser la communication inter-conteneurs mentionnée ci-dessus dans la tâche et la communication inter-tâches. Tout d'abord, afin de réaliser la communication entre les conteneurs, nous décrirons db-service et mysql.

Déployez et essayez la communication HTTP

Après avoir déployé le correctif jusqu'à présent, si vous vérifiez l'état avec la commande ```ecs-cli compose ~ service ps ~ `` , il sera RUNNING` pour le moment. En fait, c'est le résultat de ps après le démarrage.

$ ecs-cli compose --project-name backend service ps --cluster-config sample-config --ecs-profile sample-profile
Name                                              State    Ports                         TaskDefinition    Health
<task-id>/db-service   RUNNING  XXX.XXX.XXX.XXX:5001->5001/tcp  backend:12  UNKNOWN
<task-id>/mysql      RUNNING  XXX.XXX.XXX.XXX:3306->3306/tcp  backend:12  UNKNOWN

Puisque l'adresse IP de Globus est affichée, j'essaie de communiquer avec le service db de Mac par GET, mais comme mentionné ci-dessus, cela ne fonctionne toujours pas.

$ curl http://XXX.XXXX.XXX.XXX:5001/students
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<title>500 Internal Server Error</title>
<h1>Internal Server Error</h1>
<p>The server encountered an internal error and was unable to complete your request. Either the server is overloaded or there is an error in the application.</p>

5-2. Modification de la communication inter-conteneurs

Comme il se trouve sur la console ECS, si vous vérifiez le journal sur l'onglet Journaux, etc., vous obtiendrez une erreur indiquant que le nom ne peut pas être résolu. Dans ce cas, j'obtiens une erreur indiquant que le nom d'hôte de mysql ne peut pas être trouvé à partir de db-service. Le fait est qu'il n'y a pas de communication entre les conteneurs. Je l'ai écrit lors du déploiement local, mais cette fois je n'utilise pas de liens. En outre, le type Fargate ne prend pas en charge les liens en premier lieu.

Ensuite, comment le résoudre, c'est que la communication inter-conteneurs de Fargate est accessible par numéro de port si elle est sur la même tâche. Modifiez donc la source de student.py comme suit. De plus, comme le codage du nom d'hôte est subtil, je vais le modifier pour qu'il soit passé en tant que variable d'environnement à partir de docker-compose.yml.

db-service/src/students.points fixes py

import json
import mysql.connector as mydb
import os  #ajouter à

def get_students():
    #Correction pour obtenir de la variable d'environnement
    conn = mydb.connect(user=os.environ['DB_USER'], passwd=os.environ['DB_PASS'],
                        host=os.environ['DB_HOST'], port=os.environ['DB_PORT'])

docker-compose.points de correction yml(db-service)

 db-service:
    -réduction-
    environment:
      DB_HOST: 127.0.0.1
      DB_USER: "user"
      DB_PASS: "password"
      DB_PORT: "3306"

Poussez à nouveau sur ECR et déployez. Si vous avez déployé sur Fargate une fois, pour refléter les changements, supprimez-le une fois avec la commande ```ecs-cli compose ~ service down ~ `dans le didacticiel, et` `ʻecs-cli compose Redémarrez avec la commande ~ service up ~ ``.

• Il semble qu'il faudra un certain temps pour que la commande down se termine même après que la commande down soit terminée.

En déployant à nouveau, db-service peut communiquer!

Vous pouvez confirmer que la communication HTTP du Mac vers le service db est réussie. Voici un aperçu des voies de communication.

1. Communication HTTP de l'extérieur (Mac) vers un microservice appelé db-service sur Fargate
2. db-service et MySQL communiquent entre les conteneurs pour obtenir des données
3. La valeur est renvoyée à la source de la demande via db-service.

$ curl http://XXX.XXX.XXX.XXX:5001/students
{"students": [{"id": "1001", "name": "Alice", "score": 60}, {"id": "1002", "name": "Bob", "score": 80}]}

• Il est un peu sécuritaire de pouvoir communiquer directement avec le service back-end, mais cette fois nous avons mis l'accent sur la facilité de compréhension. Peut-être l'illusion qu'il devrait être réglé par un groupe de sécurité en production.

5-3. Modification de la communication inter-tâches

Ensuite, laissez le service apl communiquer. Comme mentionné précédemment, apl-service exécute l'API db-service, il doit donc communiquer avec une autre tâche. Pour y parvenir avec Fargate, activez la détection et le lancement du service. Le mécanisme de détection de service est omis car l'article suivant de Classmethod est très facile à comprendre, mais en bref, l'enregistrement A de Route53 est automatiquement créé entre les microservices et la détection de nom est possible.

ECS Service Discovery est arrivé à Tokyo, ce qui facilite la mise en œuvre de la communication inter-conteneurs!

Puisque nous utilisons ecs-cli cette fois, nous allons le déployer avec des commandes en nous référant au didacticiel officiel AWS suivant.

[Tutoriel: Créer un service Amazon ECS qui utilise la découverte de services à l'aide de l'interface de ligne de commande Amazon ECS](https://docs.aws.amazon.com/ja_jp/AmazonECS/latest/developerguide/ecs-cli-tutorial-servicediscovery .html)

Le nom d'hôte lorsque le service est détecté est service_name.namespace. Cette fois, le nom du service est créé en tant que backend et l'espace de noms est créé en tant qu'exemple, donc pour accéder à db-service depuis apl-service, il est nécessaire de définir le nom d'hôte backend.sample. Ainsi, comme avec db-service, modifiez-le pour définir le nom d'hôte à partir de la variable d'environnement.

apl-service/src/server.points fixes py

from flask import Flask, request, abort, render_template, send_from_directory
from results import get_results
import os  #ajouter à

#Correction pour obtenir de la variable d'environnement
API_URI = 'http://' + os.environ['BACKEND_HOST'] +':' + os.environ['BACKEND_PORT'] + '/students'

docker-compose.points de correction yml(apl-service)

 apl-service:
    -réduction-
    environment:
      BACKEND_HOST: "backend.sample"
      BACKEND_PORT: "5001"

Vous êtes maintenant prêt à partir. Poussez à nouveau le conteneur de service apl sur ECR. Si db-service et mysql sont déjà en cours d'exécution, il est nécessaire de définir et de déployer sur le même espace de noms, alors supprimez le service une fois. Ensuite, dans le dossier qui contient chaque fichier docker-compose.yml, ajoutez des options d'espace de noms et déployez. Les noms de service sont respectivement backend et apl.

Déployer le service backend

$ ecs-cli compose --project-name backend service up --private-dns-namespace sample --vpc <vpc-id> --enable-service-discovery --ecs-profile sample-profile

Déployer le service APL

$ ecs-cli compose --project-name apl service up --private-dns-namespace sample.com --vpc <vpc-id> --enable-service-discovery --ecs-profile sample-profile

En guise d'avertissement, vous devez également ajouter --ecs-profile à la commande deploy dans le didacticiel.

communication avec apl-service!

$ curl http://XXX.XXX.XXX.XXX:5002/results
{"addedStudents": [{"id": "1001", "name": "Alice", "score": 60, "isPassed": false}, {"id": "1002", "name": "Bob", "score": 80, "isPassed": true}]}

Enfin, la communication de apl-service a été confirmée. Voici un aperçu des voies de communication.

1. Communication HTTP de l'extérieur (Mac) vers le service apl sur Fargate
2. apl-service exécute l'API db-service
3. db-service et MySQL communiquent entre les conteneurs pour obtenir des données
4. La valeur est renvoyée à la source de la demande via db-service et apl-service.

6. Récapitulatif des commandes source et de déploiement

J'ai beaucoup corrigé, je vais donc résumer les commandes source et déployer qui ont changé. De plus, la région a été faite avec ap-nord-est-1, mais veuillez noter que ceux qui utilisent un autre doivent changer.

Lié à MySQL

mysql/Dockerfile

FROM mysql/mysql-server:5.7

COPY ./db/mysql_init/setup.sql /docker-entrypoint-initdb.d/setup.sql

RUN chown -R mysql /var/lib/mysql && \
    chgrp -R mysql /var/lib/mysql

setup.sql est omis car il est inchangé

lié au service db

db-service/Dockerfile

FROM python:3.6

#Travailler DIR sur le conteneur
WORKDIR /usr/src/

#Installation de la bibliothèque
RUN pip install flask mysql-connector-python

#Copiez la source dans le conteneur
COPY ./src/server.py /usr/src/server.py 
COPY ./src/students.py /usr/src/students.py 

CMD python ./server.py

db-service / src / server.py n'a pas changé, il est donc omis.

db-service/src/students.py

import json
import mysql.connector as mydb
import os


def get_students():
    conn = mydb.connect(user=os.environ['DB_USER'], passwd=os.environ['DB_PASS'],
                        host=os.environ['DB_HOST'], port=os.environ['DB_PORT'])

    cur = conn.cursor()
    sql_qry = 'select id, name, score from DB01.students;'
    cur.execute(sql_qry)

    rows = cur.fetchall()

    results = [{"id": i[0], "name": i[1], "score": i[2]} for i in rows]
    return_json = json.dumps({"students": results})
    cur.close()
    conn.close()

    return return_json

lié au service apl

apl-service/Dockerfile

FROM python:3.8

#Travailler DIR sur le conteneur
WORKDIR /usr/src/

#Installation de la bibliothèque
RUN pip install requests flask

#Copiez la source dans le conteneur
COPY ./src/server.py /usr/src/server.py 
COPY ./src/results.py /usr/src/results.py 

CMD python ./server.py

apl-service/src/server.py

from flask import Flask, request, abort, render_template, send_from_directory
from results import get_results

API_URI = 'http://db-service:5001/students'

app = Flask(__name__)


@app.route('/results', methods=['GET'])
def local_endpoint():
    return get_results(API_URI)


if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5002)

ʻApl-service / src / results.py` n'a pas changé, donc il est omis.

docker-compose (db-service, mysql)

docker-compose.yml

# aws_account_id,la région doit être modifiée en fonction de la situation réelle
version: '3'

services:
  mysql:
    image: <aws_account_id>.dkr.ecr.ap-northeast-1.amazonaws.com/python-mysql/mysql
    ports:
      - "3306:3306"
    environment:
      MYSQL_USER: user
      MYSQL_PASSWORD: password
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: DB01
    command: mysqld --character-set-server=utf8 --collation-server=utf8_unicode_ci --skip-character-set-client-handshake
    logging:
      driver: awslogs
      options: 
        awslogs-group: python-docker
        awslogs-region: ap-northeast-1
        awslogs-stream-prefix: mysql

  db-service:
    image: <aws_account_id>.dkr.ecr.ap-northeast-1.amazonaws.com/python-mysql/db-service
    ports:
      - "5001:5001"
    environment:
      DB_HOST: 127.0.0.1
      DB_USER: "user"
      DB_PASS: "password"
      DB_PORT: "3306"
    logging:
      driver: awslogs
      options: 
        awslogs-group: python-docker
        awslogs-region: ap-northeast-1
        awslogs-stream-prefix: db-service

docker-compose (apl-service)

docker-compose.yml

# aws_account_id,la région doit être modifiée en fonction de la situation réelle
version: '3'

services:
  apl-service:
    image: <aws_account_id>.dkr.ecr.ap-northeast-1.amazonaws.com/python-mysql/apl-service
    ports:
      - "5002:5002"
    environment:
      BACKEND_HOST: "backend.sample"
      BACKEND_PORT: "5001"
    logging:
      driver: awslogs
      options: 
        awslogs-group: python-docker
        awslogs-region: ap-northeast-1
        awslogs-stream-prefix: apl-service

• ecs-params.yml est OK si vous le créez selon le tutoriel, donc omettez-le

Déployer la commande

Nous couvrirons les principales parties de l'étape 3 du didacticiel (Création d'un cluster de tâches Fargate à l'aide de l'interface de ligne de commande Amazon ECS), mais celles avec des commentaires sont les modifications. Remplacez les parenthèses et les régions par des valeurs réelles.

Étape 3

$ ecs-cli up --cluster-config sample-config --ecs-profile sample-profile
$ aws ec2 describe-security-groups --filters Name=vpc-id,Values=<vpc-id> --region ap-northeast-1
$ aws ec2 authorize-security-group-ingress --group-id <security-group-id> --protocol tcp --port 80 --cidr 0.0.0.0/0 --region ap-northeast-1
# 5001,5002 également autorisé
$ aws ec2 authorize-security-group-ingress --group-id <security-group-id> --protocol tcp --port 5001 --cidr 0.0.0.0/0 --region ap-northeast-1
$ aws ec2 authorize-security-group-ingress --group-id <security-group-id> --protocol tcp --port 5002 --cidr 0.0.0.0/0 --region ap-northeast-1

Étape 5

#Déployer le backend-Ajout d'une option pour créer un espace de noms pour la découverte de services
$ ecs-cli compose --project-name backend service up --create-log-groups --cluster-config sample-config --private-dns-namespace sample --vpc <vpc-id> --enable-service-discovery --ecs-profile sample-profile
#déployer apl-Identique au backend
$ ecs-cli compose --project-name apl service up --create-log-groups --cluster-config sample-config --private-dns-namespace sample --vpc <vpc-id> --enable-service-discovery --ecs-profile sample-profile

• Puisque deux déploiements sont effectués, deux commandes suivantes sont également exécutées.

Étape 6

$ ecs-cli compose --project-name backend service up --private-dns-namespace sample --vpc <vpc-id> --enable-service-discovery --ecs-profile sample-profile
$ ecs-cli compose --project-name apl service up --private-dns-namespace sample.com --vpc <vpc-id> --enable-service-discovery --ecs-profile sample-profile

Étape 10

$ ecs-cli compose --project-name backend service down --cluster-config sample-config --ecs-profile sample-profile
$ ecs-cli compose --project-name apl service down --cluster-config sample-config --ecs-profile sample-profile
$ ecs-cli down --force --cluster-config sample-config --ecs-profile sample-profile

Ce que j'ai appris (ce à quoi j'étais accro)

--Image de l'utilisation d'applications de micro-service sur Fargate --Mécanismes et méthodes de communication intra-tâche et de communication inter-tâche dans ECS

• Diverses restrictions telles que Fargate ne prend pas en charge les volumes de stockage persistants

finalement

Je sens que j'ai approfondi ma compréhension non seulement de Fargate mais aussi des microservices en général parce que j'ai fait des microservices avec un scratch complet. J'ai beaucoup écrit sur ce à quoi j'étais accro, donc c'était peut-être un article difficile à comprendre. Cela fait longtemps, mais merci d'avoir lu. Je vous serais très reconnaissant si vous pouviez signaler ou poser des questions.

référence

• Créer un environnement python (jupyter) + MySQL à l'aide de docker compose
• Lorsque vous souhaitez communiquer entre des conteneurs avec AWS Fargate
• Utiliser mysql avec docker
• AWS Fargate
• Docker à partir d'aujourd'hui [Concept de base]
• Organisation des concepts du service de conteneur Amazon EC2 (ECS) --Autres tutoriels et blogs officiels AWS