[Partie 2] Testez et déployez automatiquement les services WEB créés avec Rails + Nuxt + MySQL + Docker avec ECS / ECR / CircleCI pour terraformer

En écrivant cet article

Créer un portefeuille à partir d'un état où je n'avais aucune connaissance d'AWS, le déploiement personnel sur AWS et le déploiement automatique de CircleCI étaient les plus difficiles, donc un mémorandum ・ Je créerai un portefeuille à partir de maintenant ・ Pour ceux qui utiliseront AWS à partir de maintenant J'ai pensé que ce serait bien s'il y avait un article.

Un aperçu du portfolio que j'ai créé [AWS? Docker?] Résumez les connaissances nécessaires dans votre portefeuille d'une manière simple à comprendre [terraform? CircleCI?]

Le prédécesseur de cet article est [Part 1] Tester / déployer automatiquement le service WEB créé avec Rails + Nuxt + MySQL + Docker avec ECS / ECR / CircleCI et le convertir en terraform

J'apprécierais si vous pouviez jeter un coup d'œil.

Premièrement: [Part 1] Déployer et terraformer automatiquement les services WEB créés avec Rails + Nuxt + MySQL + Docker avec ECS / ECR / CircleCI 2ème: Cet article Troisièmement: [Partie 2] Déployez automatiquement le service WEB créé avec Rails + Nuxt + MySQL + Docker avec ECS / ECR / CircleCI et faites-le terraformer

Objectifs de cet article

• Vous pouvez définir des paramètres réseau de base tels que VPC, IGW, sous-réseau, table de routage et groupe de sécurité.
• Vous pouvez créer un service WEB qui permet une communication SSL constante à l'aide de Route53, ACM et ALB. --Peut être déployé dans un environnement de production à l'aide d'ECS / ECR.
• Vous pouvez utiliser CircleCI pour pousser à maîtriser et déployer automatiquement en même temps.

supposition

• Compte AWS / compte IAM / paire de clés obtenue (vous devriez pouvoir le faire tout de suite) --Aws-cli est installé --La région utilisée est Tokyo (ap-nord-est-1) ――Nous procédons à la mise en œuvre jusqu'à l'article précédent.
  [Part 1] Tester / déployer automatiquement le service WEB créé avec Rails + Nuxt + MySQL + Docker avec ECS / ECR / CircleCI et le convertir en terraform

Produit fini

qiita-sample-app

Remarque

Ce que vous pouvez faire avec cet article est généralement ** payant ** au-delà de l'offre gratuite d'AWS. De plus, parce que vous obtenez un domaine avec votre nom.com, cela coûte également ** de l'argent. ** ** Veuillez lire uniquement ceux qui pensent qu'il s'agit de frais d'étude et qui peuvent les diviser. Pour le moment, j'aimerais publier un service Web faiblement couplé utilisant ECS et ECR! Pour ceux qui disent.

Construire un réseau

Tout d'abord, nous allons créer un réseau sur l'écran AWS. Soyons enthousiastes!

Création de VPC

Connaissance des haricots

Le bloc CIDR est une abréviation de Classless Inter-Domain Routing. Une des méthodes de notation de l'adresse IP. En termes simples, c'est la gamme des VPC.

Au fait, ici, c'est un affichage comme «/ 16». En notation CIDR, il s'écrit «/ 16», «/ 24», «32».

/ 16 peut spécifier jusqu'au troisième octet. Par exemple, le «0.0» de 10.20.0.0 Vous pouvez spécifier cette partie.

/ 24 peut spécifier jusqu'au 4e octet. Par exemple, le dernier «0» de 10.20.0.0 Vous pouvez spécifier cette partie.

/ 32 peut spécifier une adresse IP spécifique.

Lors de la création d'un VPC, vous devez sécuriser une adresse IP dans le sous-réseau ou AZ à l'intérieur, et le changement ne fonctionne pas, donc Dans de nombreux cas, spécifiez / 16 pour sécuriser de nombreuses adresses IP disponibles.

Créer un sous-réseau

Ici, nous utilisons AZ ** ap-nordest-1a et ap-nordest-1c **. La raison d'utiliser les deux AZ est que nous utiliserons ALB plus tard.

Créez le sous-réseau suivant à partir de Submarine> Create Subsection.

Créer une table de routage

Créez la table de routage suivante à partir de Table de routage> Créer une table de routage.

Créer un IGW

Créez la passerelle Internet suivante à partir de Internet Gateway> Créer une passerelle Internet.

Associez VPC et IGW.

Association du sous-réseau et de la table de routage

--Sélectionnez l'onglet Modifier de la table de routage et associez l'IGW créé précédemment à 0.0.0.0 pour la table de routage autre que RDS. --Sélectionnez l'onglet Association sous-marine et associez-le comme indiqué dans le tableau ci-dessous.

Créer un groupe de sécurité

Créez un groupe de sécurité dans le tableau ci-dessous

C'est la fin du réseau.

Création de Route53 (facturé à partir d'ici)

Obtention d'un domaine

Obtenez le domaine sur Name.com. Veuillez obtenir le domaine que vous aimez (de préférence 1 yen) qui fait référence à cet article.

Pour savoir comment obtenir un domaine avec votre nom.com, veuillez consulter [Obtenir un domaine] Obtenir un domaine avec votre nom.com et aws.

** * Désactivez le paramètre de mise à jour automatique du domaine! (Cela coûte de l'argent chaque année) **

Cette fois, dans mon environnement, j'ai les domaines suivants.

Créer une zone hébergée

Créez une zone hôte à partir de Route53.

À partir des détails de la zone hôte, copiez la ** valeur / destination de routage du trafic ** de l'enregistrement NS.

Enregistrez la valeur de l'enregistrement NS dans le serveur de noms de votre nom.com

Il faudra un certain temps pour réfléchir. (Cela peut prendre jusqu'à 1 jour)

dig qiita-sample.work(Domaine acquis) +short NS

Est tapé à partir du terminal, et si l'enregistrement NS enregistré avec succès est affiché, il est reflété.

Émettre un certificat vers un domaine à l'aide d'ACM

Demandez un certificat à ACM. Sélectionnez Demander un certificat public pour demander un certificat.

Remplissez le nom de domaine ci-dessus et sélectionnez la validation DNS. De même, faites de même pour qiita-sample-api.work.

Ensuite, vous serez redirigé vers l'écran de vérification, où vous allez ** créer un enregistrement avec Route53 **. (Créez des enregistrements dans tous les domaines ci-dessus.) Après un certain temps, la vérification sera en attente et le statut sera publié. Si la vérification est en attente pendant une longue période, il est possible que les paramètres du serveur NS soient retardés. Vérifions avec la commande dig.

Création de RDS

La configuration de Route53 et du serveur de noms de domaine prend un certain temps, alors créons rapidement RDS ici.

Créer un groupe de sous-réseaux

Création / configuration RDS

Créez RDS en sélectionnant RDS> Créer une base de données, en vous référant aux paramètres suivants.

Après un certain temps, il sera disponible, puis la création de RDS est terminée.

Modification de database.yml et credentials.yml.enc

yml:./back/config/database.yml

production:
  <<:         *default
  host:       <%= Rails.application.credentials.rds[:host] %>
  database:   <%= Rails.application.credentials.rds[:database] %>
  username:   <%= Rails.application.credentials.rds[:username] %>
  password:   <%= Rails.application.credentials.rds[:password] %>

./

docker-compose run -e EDITOR="vi" back rails credentials:edit 

Ensuite, l'écran vim apparaîtra, alors entrez les paramètres suivants.

rds:
  host: {point final}
  database: {nom de la base de données (créé au début)}
  username: {Définir le nom d'utilisateur}
  password: {Définir le mot de passe}

Créer un équilibreur de charge

Créons un équilibreur de charge à partir d'EC2> Créer un équilibreur de charge.

Paramètres de l'équilibreur de charge

front

back Enregistrez le VPC et le sous-réseau que vous avez créés précédemment dans la zone de disponibilité.

Configuration des paramètres de sécurité

Sélectionnez le certificat que vous avez créé précédemment. Si vous n'avez pas encore été certifié, attendez une minute.

Paramètres du groupe de sécurité

Veuillez joindre le groupe de sécurité que vous avez créé précédemment.

Paramètres de routage

Créez un nouveau groupe cible. Cette fois en face, pour démarrer en ** mode hôte ** dans EC2 généré par ECS Définissez la cible sur l'instance et acceptez le port à 3000. À l'arrière, la cible est ip car elle démarre en ** mode awsvpc ** dans le conteneur dans l'instance d'ECS. Cela fait référence à l'adresse IP privée du conteneur.

front

back

Enregistrement cible

Comme nous le verrons plus tard, ne vous inquiétez pas, la cible sera sélectionnée automatiquement au démarrage du service ECS. Créons un équilibreur de route tel qu'il est!

Enregistrement A ajouté à Route53

À partir de Route53> Zone hôte, ajoutez un enregistrement A et définissez-le comme suit. Veuillez traiter le recto et le verso de la même manière.

Créer un référentiel dans ECR / image push

Changeons l'orientation de l'API frontale pour la production.

js:./front/plugins/axios.js

import axios from "axios"

export default axios.create({
  //baseURL: "http://localhost:3000"
  baseURL: "https://www.qiita-sample-api.work"
})

** * Rendons aws cli disponible! ** ** Installez l'AWS CLI version 1 sur macOS Installez l'AWS CLI

Créez un référentiel à partir d'Amazon ECR. Veuillez remplir le nom du référentiel et le créer tel quel. Sélectionnez un référentiel et appuyez sur la commande push pour afficher les commandes à pousser vers le référentiel. Créez un référentiel pour l'avant et l'arrière et exécutez-le dans l'environnement local.

Lorsque vous exécutez ces commandes, une image est créée en fonction du Dockerfile dans le répertoire. Il sera dans le même état que lorsque la construction de docker-compose est effectuée dans l'environnement local. En utilisant l'image créée ici et poussée vers ECR, chargez-la sur ECS et démarrez-la.

Veuillez noter que vous devez vérifier dans quel référentiel vous voulez pousser, ** avant ou arrière, puis vous déplacer vers le répertoire où se trouve le Dockerfile avant de l'exécuter. ** **

Création / paramétrage ECS

Vue d'ensemble

Dans ECS Cluster> Services> Tâches C'est devenu la taille des grains. Un cluster est un cadre logique, une boîte. Le service est comme la mise à l'échelle automatique + ALB qui démarre sur le cluster. Gérez automatiquement le nombre de tâches et configurez les paramètres réseau. Considérez une tâche comme une unité qui exécute une image Docker.

Le service crée des tâches en fonction de la définition de la tâche. En le comparant de force, le moule taiyaki est un service, et le taiyaki lui-même est comme une tâche. Le cluster est le stand d'un magasin de taiyaki.

Créer un cluster ECS

Cette fois, j'ai choisi EC2 Linux + réseau

Pour la mise en réseau, sélectionnez le VPC / sous-réseau (avant) que vous avez créé précédemment. Sélectionnez également Activé pour Attribution automatique de l'adresse IP publique. Définissons la paire de clés afin que vous puissiez vous connecter avec ssh.

Paires de clés Amazon EC2 et instances Linux

Après avoir créé le cluster, si l'instance EC2 est démarrée comme indiqué ci-dessous, elle réussit. Bonne chose Si les instances EC2 ne sont pas liées, les groupes de sécurité et les tables de routage sont souvent le problème.

Créer une définition de tâche

Sélectionnez Créer une nouvelle définition de tâche à partir d'ECS

Sélectionnez EC2

front

back

Créer un service

Créez un service à partir de la balise de service du cluster.

front

Pour l'équilibrage de charge, sélectionnez Equilibreur de charge d'application et sélectionnez l'ALB et la cible créés précédemment.

back

Dans la configuration du réseau, sélectionnez le VPC et le groupe de sécurité de sous-réseau arrière créés précédemment. Pour l'équilibrage de charge, sélectionnez Equilibreur de charge d'application et sélectionnez l'ALB et la cible créés précédemment.

Démarrer le service ECS

Une fois créée comme ci-dessus, une tâche doit être ajoutée automatiquement. Si cela ressemble à ce qui suit, c'est OK! Le conteneur aurait dû être démarré à l'intérieur d'EC2 à partir de l'image en toute sécurité.

db:migrate Vous pouvez créer une définition de tâche et exécuter la tâche, mais cette fois je vais ssh me connecter à l'instance EC2, puis aller à l'intérieur du conteneur docker et essayer rails db: migrate. À l'origine, je devais créer une base de données (db: create), mais cette fois j'ai défini RDS comme production dans la base de données initiale lors de sa création, et ce n'est pas nécessaire car elle a déjà été créée.

[Fichier Pem DL](https://qiita.com/Shogo1222/items/dcbc1e50f6fc83f48b44#ecs%E3%82%AF%E3%83%A9%E3%82%B9%E3%82%BF% E3% 83% BC% E3% 81% AE% E4% BD% 9C% E6% 88% 90)

ssh -i {chemin du fichier pem} ec2-user@{IP publique de l'instance}


   __|  __|  __|
   _|  (   \__ \   Amazon Linux 2 (ECS Optimized)
 ____|\___|____/

For documentation, visit http://aws.amazon.com/documentation/ecs

Dans une instance EC2

docker ps

Affiche le conteneur en cours d'exécution. Spécifiez l'ID CONTAINER des rails exécutant le conteneur et saisissez la commande suivante pour le placer dans le conteneur Docker.

Dans une instance EC2

docker exec -it {CONTAINER ID} sh

Ici, spécifions l'environnement et db: migrate!

Dans le conteneur Docker

rails db:migrate RAILS_ENV=production

Confirmation de démarrage

Je vous remercie pour votre travail acharné!

ttps: // www. {Domaine frontal défini par moi-même} / users C'est OK si vous pouvez accéder et enregistrer l'utilisateur ainsi que local, comme indiqué dans l'écran ci-dessous. ttps: // www. {Domaine arrière défini par moi-même} / users C'est OK si vous accédez et que le json de l'utilisateur enregistré est renvoyé.

Déploiement automatique avec CircleCI

Après avoir poussé à master dans le dernier, CircleCI, mettons à jour la définition de la tâche automatiquement, mettons à jour le service ECS et rendons possible la mise à jour de la tâche.

Flux global

Pousser du local au github
→ Démarrez CircleCI depuis github
→ Exécutez docker build sur CircleCI
→ Poussez l'image vers ECR sur CircleCI
→ Mettre à jour le service ECS ...

Ce sera.

Connaissance des haricots

La différence avec la construction locale est la présence ou l'absence de variables d'environnement.

La compilation exécutée sur CircleCI ** fait référence au code source dans le référentiel git ** et est également ** en cours d'exécution dans une machine virtuelle **. Si les variables d'environnement requises pour exécuter Rails n'existent pas sur le référentiel git, les variables d'environnement ne peuvent pas être référencées et échoueront. Cependant, CircleCI vous permet de définir des variables d'environnement sur la machine virtuelle.

Définition des variables d'environnement

Project Settings>Environment Variables

AWS_ACCESS_KEY_ID //Clé d'accès AWS
AWS_SECRET_ACCESS_KEY //Clé d'accès secrète AWS
AWS_ACCOUNT_ID //Voir l'URL ci-dessous
AWS_ECR_ACCOUNT_URL //Exemple d'URL ECR:{identifiant de compte}.dkr.ecr.{Région}.amazonaws.com
AWS_REGION //Région

RAILS_MASTER_KEY // ./back/config/Master ci-dessous.valeur de la clé
AWS_RESOURCE_NAME_PREFIX //Préfixe du service que j'ai créé (qiita cette fois-sample）
CLUSTER_NAME //Le nom du cluster créé précédemment
REPO_NAME_FRONT //Nom du référentiel ECR du front
REPO_NAME_BACK //Nom du référentiel ECR du dos
FAMILY_NAME_FRONT //Le nom de la définition de tâche de front
FAMILY_NAME_BACK //Le nom de la définition de tâche de retour
SERVICE_NAME_FRONT //Le nom du service ECS frontal créé précédemment
SERVICE_NAME_BACK //Le nom du service ECS frontal créé précédemment

Confirmer l'ID de compte AWS

paramètres config.yml

yml:./front/.circleci/config.yml

version:                                  2.1
orbs:
  aws-ecr:                                circleci/[email protected]
  aws-ecs:                                circleci/[email protected]

#Tâche à exécuter
jobs:
  #travail à construire
  build:
    machine:
      image:                              circleci/classic:edge
    steps:
      - checkout
      - run:
          name:                           docker-compose build
          command:                        docker-compose build
  #travail à tester
  test:
    machine:
      image:                              circleci/classic:edge
    steps:
      - checkout
      - run:
          name:                           docker-compose up -d
          command:                        docker-compose up -d
      - run:                              sleep 30
      - run:
          name:                           docker-compose run back rails db:create RAILS_ENV=test
          command:                        docker-compose run back rails db:create RAILS_ENV=test
      - run:
          name:                           docker-compose run back rails db:migrate RAILS_ENV=test
          command:                        docker-compose run back rails db:migrate RAILS_ENV=test
      - run:
          name:                           docker-compose run back bundle exec rspec spec
          command:                        docker-compose run back bundle exec rspec spec
      - run:
          name:                           docker-compose down
          command:                        docker-compose down

#Workflow pour contrôler la commande
workflows:
  build_and_test_and_deploy:
    jobs:
      - build
      - test:
          requires:
            - build
      - aws-ecr/build-and-push-image:
            name:                         'build-and-push-back'
            account-url:                  AWS_ECR_ACCOUNT_URL
            region:                       AWS_REGION
            repo:                         ${REPO_NAME_BACK}
            tag:                          "${CIRCLE_SHA1}"
            path:                         './back'
            dockerfile:                   back/Dockerfile.pro
            extra-build-args:             '--build-arg RAILS_MASTER_KEY=$RAILS_MASTER_KEY'
            requires:
              - test
            filters:
              branches:
                only:
                  - master
      - aws-ecr/build-and-push-image:
            name:                         'build-and-push-front'
            account-url:                  AWS_ECR_ACCOUNT_URL
            region:                       AWS_REGION
            repo:                         ${REPO_NAME_FRONT}
            tag:                          "${CIRCLE_SHA1}"
            path:                         './front'
            dockerfile:                   front/Dockerfile.pro
            requires:
              - test
            filters:
              branches:
                only:
                  - master
      - aws-ecs/deploy-service-update:
            family:                       ${FAMILY_NAME_BACK}
            service-name:                 ${SERVICE_NAME_BACK}
            cluster-name:                 ${CLUSTER_NAME}
            #"container="Veuillez noter que c'est le nom du conteneur défini dans la définition de tâche.
            container-image-name-updates: 'container=${AWS_RESOURCE_NAME_PREFIX}-back,image-and-tag=${AWS_ECR_ACCOUNT_URL}/${REPO_NAME_BACK}:${CIRCLE_SHA1}'
            requires:
              - build-and-push-back
            filters:
              branches:
                only:
                  - master
      - aws-ecs/deploy-service-update:
            family:                       ${FAMILY_NAME_FRONT}
            service-name:                 ${SERVICE_NAME_FRONT}
            cluster-name:                 ${CLUSTER_NAME}
　　　　　　　 #"container="Veuillez noter que c'est le nom du conteneur défini dans la définition de tâche.
            container-image-name-updates: 'container=${AWS_RESOURCE_NAME_PREFIX}-front,image-and-tag=${AWS_ECR_ACCOUNT_URL}/${REPO_NAME_FRONT}:${CIRCLE_SHA1}'
            requires:
              - build-and-push-front
            filters:
              branches:
                only:
                  - master

Créer un Dockerfile de production

dockerfile:./back.Dockerfile.pro

#Spécifier une image
FROM ruby:2.6.3-alpine3.10

#Télécharger les packages requis
ENV RUNTIME_PACKAGES="linux-headers libxml2-dev make gcc libc-dev nodejs tzdata mysql-dev mysql-client yarn" \
    DEV_PACKAGES="build-base curl-dev" \
    HOME="/app" \
    LANG=C.UTF-8 \
    TZ=Asia/Tokyo

#Déplacer vers le répertoire de travail
WORKDIR ${HOME}

#Copiez les fichiers nécessaires de l'hôte (fichiers sur votre ordinateur) vers Docker
ADD Gemfile ${HOME}/Gemfile
ADD Gemfile.lock ${HOME}/Gemfile.lock

RUN apk update && \
    apk upgrade && \
    apk add --update --no-cache ${RUNTIME_PACKAGES} && \
    apk add --update --virtual build-dependencies --no-cache ${DEV_PACKAGES} && \
    bundle install -j4 && \
    apk del build-dependencies && \
    rm -rf /usr/local/bundle/cache/* \
    /usr/local/share/.cache/* \
    /var/cache/* \
    /tmp/* \
    /usr/lib/mysqld* \
    /usr/bin/mysql*

#Copiez les fichiers nécessaires de l'hôte (fichiers sur votre ordinateur) vers Docker
ADD . ${HOME}

#Ouvrir le port 3000
EXPOSE 3000

#Exécuter la commande
CMD ["bundle", "exec", "rails", "s", "puma", "-b", "0.0.0.0", "-p", "3000", "-e", "production"]

dockerfile:./front/Dockerfile.pro

FROM node:12.5.0-alpine

ENV HOME="/app" \
    LANG=C.UTF-8 \
    TZ=Asia/Tokyo

ENV HOST 0.0.0.0

WORKDIR ${HOME}
COPY package.json .
COPY . .

RUN apk update && \
    apk upgrade && \
    npm install -g n && \
    yarn install &&\
    rm -rf /var/cache/apk/*

RUN yarn run build
EXPOSE 3000
CMD ["yarn", "start"]

yml:./docker-compose.yml

version:                "3"

services:
  db:
    image:              mysql:5.7
    env_file:
      - ./back/environments/db.env
    restart:            always
    volumes:
      - db-data:/var/lib/mysql:cached

  back:
    build:              back/
    # rm -f tmp/pids/server.Utile lorsque vous ne parvenez pas à effacer le serveur de rails avec pid
    command:            /bin/sh -c "rm -f tmp/pids/server.pid && bundle exec rails s -p 3000 -b '0.0.0.0'"
    env_file:
      - ./back/environments/db.env
    environment: #ajouter à
      RAILS_MASTER_KEY: ${RAILS_MASTER_KEY}
    volumes:
      - ./back:/app:cached
    depends_on:
      - db
    #Port de l'ordinateur hôte: port dans Docker
    ports:
      - 3000:3000

  front:
    build:              front/
    command:            yarn run dev
    volumes:
      - ./front:/app:cached
    ports:
      #Port de l'ordinateur hôte: port dans Docker
      - 8080:3000
    depends_on:
      - back
volumes:
  public-data:
  tmp-data:
  log-data:
  db-data:

Déployer

Je vous remercie pour votre travail acharné! Comme indiqué ci-dessous, si toutes les étapes réussissent, le déploiement est terminé avec succès.

référence

Ceux qui veulent en savoir plus sur VPC, le réseau AWS, etc. Cours AWS appris avec le VPC vidéo [section1] Région, zone de disponibilité, sous-zone

Ceux qui veulent en savoir plus sur le réseau de Docker et ECS Cours Docker à rattraper à partir de maintenant! Visez le Container Master avec AWS ECS et Fargate! ~ Série 1ère ~

C'est un moment vraiment pratique pour apprendre des vidéos ... Je l'ai répété environ 30 fois.

finalement

Je vous remercie pour votre travail acharné. Vous pouvez désormais déployer Nuxt et Rails en production à l'aide d'ECS / ECR / CircleCI. Ce n'est qu'un exemple, et je pense qu'il existe d'autres bonnes configurations. Cependant, une fois que vous l'avez construit et débogué, vous saurez comment le faire. (J'ai encore plus Il y a peut-être des fautes de frappe ou des erreurs dans cet article. Dans un tel cas, j'apprécierais que vous jetiez doucement Masakari.

La prochaine fois, j'aimerais pouvoir écrire sur terraform.