[Pour les super débutants (plus de pression)] Déploiement automatique sur AWS ECR / ECS avec Ruby2.6 x Rails6 x CircleCi [format pratique]

Configuration visée dans cet article

① pousser sur GitHub ② La construction s'exécute sur CircleCi ③ Si le test (Rspec) est réussi, créez une image Docker et transmettez-la à ECR. (4) Utilisez la dernière image Docker, mettez à jour la définition de tâche ECS et terminez le déploiement.

Public cible

• Les personnes qui n'ont jamais touché ECS
• Les personnes qui veulent bouger leurs mains et se faire une idée de l'atmosphère --Les personnes qui créent un portefeuille pour la recherche d'emploi

Étapes pour déployer une application Rails simple (affichez simplement "Hello World!") Sur AWS ECS. Veuillez noter que nous ne prenons pas en considération l'opération ultérieure, et ce n'est qu'à titre indicatif.

Il existe probablement différentes façons de le faire en fonction de la personne, donc une fois que vous avez compris le flux, veuillez le régler à votre guise.

Dès la préparation de l'application pour le déploiement, tout est décrit dans un format pratique (beaucoup de sukusho), et si vous procédez comme écrit, cela devrait fonctionner.

Il y a une partie pour définir des valeurs arbitraires (nom du profil, nom de l'application, etc.) à des points importants, donc si vous n'êtes pas sûr, il peut être préférable de s'unifier avec "sample-app" etc. comme l'auteur.

`* Bien qu'il soit étiqueté pour les débutants, il n'explique pas chaque terme car il est dédié au but de« bouger d'abord les mains pour avoir une idée de l'atmosphère ». ''

`` * Le concept est que même un super débutant d'AWS peut se déployer comme ça si vous suivez les instructions pour le moment. Si vous êtes un théoricien, nous vous recommandons de vous renseigner sur le concept d'ECR / ECS dans d'autres articles avant d'entrer. (Parce que je m'en souviens avec mon corps ...) `

`` * Comme pour chaque nom de ressource d'AWS, il est fondamentalement arbitraire, vous pouvez donc l'utiliser comme vous le souhaitez (cependant, lorsque vous tapez une commande avec ecs-cli ou que vous devez faire correspondre la description dans la configuration de CircleCi). Aussi, pour les parties qui ne sont pas mentionnées en particulier, je pense que l'état par défaut ou les blancs sont corrects pour le moment. ''

* Le numéro de révision peut varier en raison des différents horaires, mais veuillez l'ignorer (transpirer)

spécification

--Langue: Ruby2.6 --Cadre: Rails6 --Base de données: MySQL5.7

• Serveur d'application: Puma
• Serveur Web: Nginx

Préparation

Tout d'abord, préparez une application Rails simple à déployer sur ECS.

échantillon

https://github.com/kazama1209/sample-app

$ git clone https://github.com/kazama1209/sample-app.git
$ cd sample-app

installer

$ docker-compose build
$ docker-compose run web bundle exec rails webpacker:install

#Si une erreur survient avec la commande ↑
$ docker-compose run web yarn install --check-files

$ docker-compose up -d
$ docker-compose run web bundle exec rails db:create

Créer master.key

Si vous avez cloné le référentiel à partir de ↑, config / master.key ne devrait pas exister. S'il n'y a pas de master.key, une erreur se produira au moment du déploiement, alors générez-la ici selon la procédure suivante.

$ rm config/credentials.yml.enc
$ docker-compose run -e EDITOR=vim web rails credentials:edit

référence: Je souhaite modifier les informations d'identification avec Rails sur Docker ActiveSupport::MessageEncryptor::InvalidMessage

Accéder à localhost

Si vous accédez à http: // localhost et que l'écran habituel est affiché, c'est OK.

Création de la première page "Hello World!"

Créez une page d'accueil qui renvoie "Hello World!", Qui est l'objectif final de cette fois.

ruby:./app/controllers/home_controller.rb

class HomeController < ApplicationController
  def index
  end
end

erb:./app/views/home/index.html.erb

<h1>Hello World!</h1>

ruby:./config/routes.rb

Rails.application.routes.draw do
  root 'home#index'
end

Lorsque "Hello World!" Est renvoyé, l'exemple d'application est prêt.

Déployer

Maintenant que l'application est prête, déployons-la sur ECS.

Installer divers outils

Cette fois, nous utiliserons les deux outils suivants pour déployer sur ECS.

• AWS CLI
• Amazon ECS CLI

$ brew install awscli
$ brew install amazon-ecs-cli

configurer aws configurer

Configurez aws configure pour utiliser les outils ci-dessus.

Créer un utilisateur IAM

Sélectionnez Services → IAM dans la console AWS et cliquez sur «Ajouter un utilisateur».

Entrez un nom d'utilisateur arbitraire ("sample-app" cette fois), cochez "Accès par programme" et passez à l'étape suivante.

À partir de «Joindre directement la politique existante», associez les deux politiques suivantes à l'étape suivante.

• AmazonECS_FullAccess
• AmazonEC2ContainerRegistryFullAccess

Ignorez les balises cette fois et passez à l'étape suivante.

Enfin, un écran de confirmation des informations de saisie s'affichera, donc s'il n'y a pas de problèmes particuliers, cliquez sur "Créer un utilisateur".

Si vous réussissez à créer un utilisateur, vous recevrez une "clé d'accès" et une "clé d'accès secrète", alors prenez des notes ou téléchargez le fichier csv et conservez-le en lieu sûr.

Exécutez "aws configure" dans le terminal

$ aws configure --profile <Le nom d'utilisateur IAM créé précédemment (cette fois "exemple"-app」）>

AWS Access Key ID #La clé d'accès que vous avez créée précédemment
AWS Secret Access Key #La clé d'accès secrète que vous avez créée précédemment
Default region name # ap-northeast-1 
Default output format # json 

Entrez comme ci-dessus pour chacun.

Créer une politique supplémentaire

Lorsque j'ai créé l'utilisateur IAM plus tôt

• AmazonECS_FullAccess
• AmazonEC2ContainerRegistryFullAccess

J'ai joint deux politiques, mais cela seul causera une erreur de permission dans l'outil appelé "ecs-cli" qui sera utilisé plus tard, donc je dois l'ajouter séparément ici.

Dans la console AWS, sélectionnez Services → IAM → Stratégies et cliquez sur Créer une stratégie.

Ouvrez l'onglet JSON et écrivez ce qui suit.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "VisualEditor0",
            "Effect": "Allow",
            "Action": [
                "iam:AttachRolePolicy",
                "iam:AddRoleToInstanceProfile",
                "iam:CreateInstanceProfile",
                "iam:CreateRole",
                "iam:DeleteInstanceProfile",
                "iam:DeleteRole",
                "iam:DetachRolePolicy",
                "iam:PassRole",
                "iam:RemoveRoleFromInstanceProfile",
                "ec2:DeleteInternetGateway",
                "ec2:DeleteSecurityGroup",
                "ec2:DeleteRouteTable"
            ],
            "Resource": "*"
        }
    ]
}

Entrez un nom et une description de la politique et cliquez sur «Créer une politique».

Joindre la stratégie à l'utilisateur

Dans la console AWS, sélectionnez Services → IAM → Utilisateurs et cliquez sur «Ajouter un accès».

Sélectionnez la stratégie que vous avez créée précédemment dans «Joindre la stratégie existante» et ajoutez des privilèges d'accès.

Créer une paire de clés

Créez une paire de clés car vous en aurez besoin plus tard lorsque vous entrerez dans EC2.

Dans la console AWS, sélectionnez Services → EC2 → Paire de clés et cliquez sur «Créer une paire de clés».

Entrez le nom et le format de fichier et cliquez sur "Créer une paire de clés".

$ mv Downloads/sample-app.pem .ssh/
$ chmod 600 ~/.ssh/sample-app.pem

Une fois terminé, un fichier au format ".pem" sera téléchargé, alors déplacez-le dans le répertoire ".ssh" et changez les permissions.

Créer un cluster

Il est possible de le créer manuellement à partir de la console, mais comme il est nécessaire de créer le vpc et le sous-réseau ensemble, cette fois, il sera créé collectivement avec ecs-cli.

Exécutez la commande suivante.

$ ecs-cli configure profile --profile-name <Tout nom de profil> --access-key <La clé d'accès que vous avez créée précédemment> --secret-key <La clé d'accès secrète que vous avez créée précédemment>
$ ecs-cli configure --cluster <Tout nom de cluster> --default-launch-type EC2 --config-name <Nom du paramètre arbitraire> --region ap-northeast-1
$ ecs-cli up --keypair <La paire de clés que vous venez de créer> --capability-iam --size 2 --instance-type t2.samll --cluster-config <Nom du paramètre arbitraire> --ecs-profile <Tout nom de profil>

Chaque valeur telle qu'une clé est différente. Dans le cas de l'auteur, cela ressemble à ce qui suit.

$ ecs-cli configure profile --profile-name sample-app --access-key ******************** --secret-key ****************************************
$ ecs-cli configure --cluster sample-app-cluster --default-launch-type EC2 --config-name sample-app-cluster --region ap-northeast-1
$ ecs-cli up --keypair sample-app --capability-iam --size 2 --instance-type t2.small --cluster-config sample-app-cluster --ecs-profile sample-app

INFO[0006] Using recommended Amazon Linux 2 AMI with ECS Agent 1.44.3 and Docker version 19.03.6-ce 
INFO[0007] Created cluster                               cluster=sample-app-cluster region=ap-northeast-1
INFO[0009] Waiting for your cluster resources to be created... 
INFO[0009] Cloudformation stack status                   stackStatus=CREATE_IN_PROGRESS
INFO[0070] Cloudformation stack status                   stackStatus=CREATE_IN_PROGRESS
INFO[0131] Cloudformation stack status                   stackStatus=CREATE_IN_PROGRESS

VPC created: vpc-*****************
Security Group created: sg-*****************
Subnet created: subnet-*****************
Subnet created: subnet-*****************
Cluster creation succeeded.

Si tout se passe bien, les VPC, les groupes de sécurité, les sous-réseaux, etc. pour le cluster seront créés automatiquement comme indiqué dans ↑.

Sélectionnez Service-> Elastic Container Service-> Cluster dans la console AWS, et s'il est créé avec succès, il réussit.

Créer RDS

Créez RDS à utiliser comme base de données.

Sélectionnez Services → RDS dans la console AWS et cliquez sur «Créer une base de données».

• Méthode de création: création standard --Type de moteur: MySQL --Taille de l'instance DB: niveau gratuit

• Identifiant d'instance DB: sample-app-db --Nom d'utilisateur maître: root --Password: mot de passe

`* Cette zone est entièrement facultative. ''

--vpc: le vpc créé précédemment

• Groupe de sous-réseaux: créer un nouveau groupe de sous-réseaux de base de données
• Accès public: Oui

`* Comme il ne s'agit que d'une pratique, j'ai sélectionné" Oui ", mais dans un environnement de production, il peut être préférable de le régler sur" Non ". ''

Premier nom de base de données: sample_app_production

* Lors de l'utilisation de l'exemple (sample-app) préparé au début de l'article, * Puisque le nom de la base de données est défini dans" config / database.yml "de sample-app, il est fixé à" sample_app_production "

`* Laissez vide ou par défaut pour les pièces intactes. ''

S'il n'y a pas de problème, cliquez sur "Créer une base de données".

↑ Succès s'il est créé comme ça.

Vous devez également définir un groupe de sécurité, cliquez donc sur le lien sous "Groupe de sécurité VPC".

Définissez comme suit dans "Modifier la règle entrante".

--Type: MYSQL / Aurora

• Protocole: TCP --Gamme port --Source: 0.0.0.0/0

$ mysql -h <Point de terminaison RDS> -u <Nom d'utilisateur RDS> -p

Essayez d'appuyer sur la commande ↑ dans le terminal, et si vous pouvez vous connecter, vous réussissez.

Créer un équilibreur de charge

Dans la console AWS, sélectionnez Services → EC2 → Load Balancer et cliquez sur «Create Load Balancer».

Il existe trois types, mais sélectionnez "Application Load Balancer".

--Name: sample-app-alb * Facultatif --Listener: OK tel quel --VPC: sélectionnez celui qui a été créé automatiquement plus tôt --subzone: Identique à ci-dessus

Si vous continuez, l'écran de paramétrage du groupe de sécurité apparaîtra, alors créez un groupe de sécurité approprié à partir de «Créer un nouveau groupe de sécurité».

Paramètres du groupe cible.

--Groupe cible: nouveau groupe cible --Name: sample-app-alb-tg * Facultatif

Enregistrez l'EC2 qui a été automatiquement créé lors de la création du cluster, et s'il n'y a pas de problème à partir de l'écran de confirmation, cliquez sur «Créer» pour terminer.

Pousser l'image du docker vers ECR

Dans la console AWS, sélectionnez Services → Amazon Elastic Container Registry et cliquez sur «Créer un référentiel».

Entrez un nom de référentiel approprié pour chacun et cliquez sur "Créer un référentiel".

Affichez la commande push et exécutez les quatre dans l'ordre du haut comme indiqué.

• Lors de la construction avec la deuxième commande, changez le contexte du Dockerfile avec -f.

#Rails (utilisez le fichier Dockerfile de production)
$ docker build -f ./prod.Dockerfile . -t sample-app-rails 

# Nginx
$ cd containers/nginx
$ docker build -f ./Dockerfile . -t sample-app-nginx 

Dockerfile pour la production

$ touch prod.Dockerfile

dockerfile:./prod.Dockerfile

FROM ruby:2.6.6
ENV LANG C.UTF-8
RUN apt-get update -qq && apt-get install -y build-essential libpq-dev nodejs

RUN curl -sL https://deb.nodesource.com/setup_8.x | bash - && \
apt-get install nodejs

RUN apt-get update && apt-get install -y curl apt-transport-https wget && \
curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - && \
echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list && \
apt-get update && apt-get install -y yarn

RUN mkdir /sample-app
WORKDIR /sample-app

ADD Gemfile /sample-app/Gemfile
ADD Gemfile.lock /sample-app/Gemfile.lock

RUN gem install bundler:2.1.4
RUN bundle install

ADD . /sample-app

#Se préparer à communiquer avec Nginx
RUN mkdir -p tmp/sockets
VOLUME /sample-app/public
VOLUME /sample-app/tmp

RUN yarn install --check-files
RUN SECRET_KEY_BASE=placeholder bundle exec rails assets:precompile

C'est fondamentalement le même que celui pour le développement, mais les dernières lignes se préparent à communiquer avec Nginx.

Après avoir tout tapé, vérifiez le référentiel, et si l'image est ajoutée, elle réussit.

Créer une tâche

Créez une tâche basée sur l'image que vous avez poussée plus tôt.

$ mkdir ecs
$ touch ecs/docker-compose.yml

yml:./ecs/docker-compose.yml

version: 2
services:
  app:
    image: #URI du référentiel ECR (Rails)
    command: bash -c "bundle exec rails db:migrate && bundle exec rails assets:precompile && bundle exec puma -C config/puma.rb"
    environment: #C'est une pratique, donc c'est un style d'écriture directe, mais je pense qu'il vaut mieux utiliser dotenv.
      RAILS_ENV: production
      RAILS_MASTER_KEY: # config/master.valeur de la clé
      DATABASE_NAME: sample_app_production
      DATABASE_USERNAME: root
      DATABASE_PASSWORD: password
      DATABASE_HOST: #Point de terminaison RDS
      TZ: Japan
    working_dir: /sample-app
    logging:
      driver: awslogs
      options:
        awslogs-region: ap-northeast-1
        awslogs-group: sample-app-production/app
        awslogs-stream-prefix: sample-app-production
  nginx:
    image: #URI du référentiel ECR (Nginx)
    ports:
      - 80:80
    links:
      - app
    volumes_from:
      - app
    working_dir: /sample-app
    logging:
      driver: awslogs
      options:
        awslogs-region: ap-northeast-1
        awslogs-group: sample-app-production/nginx
        awslogs-stream-prefix: sample-app-production

Exécutez la commande suivante.

$ ecs-cli compose --project-name sample-app-task -f ./ecs/docker-compose.yml up --create-log-groups --cluster-config sample-app-cluster --ecs-profile sample-app

En cas de succès, un "1" sera affiché pour la tâche en cours.

Enfin, accédez en collant le nom DNS de l'équilibreur de charge dans l'URL.

Succès si "Hello World!" Est affiché de la même manière que celui créé dans l'environnement local.

• Si quelque chose ne va pas pendant le déploiement, vérifiez le journal CloudWatch et corrigez-le.

Créer un service

L'application fonctionne uniquement avec le cluster et la tâche, mais si vous créez quelque chose appelé «service» au milieu, elle redémarrera lorsque le conteneur s'arrêtera, ou elle sera mise à l'échelle automatiquement via l'équilibreur de charge, je l'ai donc créée parce que c'est pratique. Garde le.

Dans la console AWS, cliquez sur Services → Amazon Elastic Container Service → Nom du cluster pour ouvrir l'onglet Services et accéder à la page Créer.

--Type de démarrage: EC2 --Définition de la tâche: sample-app-task * Celle créée précédemment --Cluster: sample-app-cluster * Identique à ci-dessus --Nom du service: sample-app-service * Facultatif --Autre: comme indiqué dans l'image

--Type d'équilibreur de charge: Equilibreur de charge d'application --Nom de l'équilibreur de route: ce que vous avez créé précédemment --Autre: comme indiqué dans l'image

• Nom du groupe cible: ce que vous avez créé précédemment --Autre: comme indiqué dans l'image

Un écran de confirmation s'affichera à la fin, donc s'il n'y a pas de problème, cliquez sur Créer.

S'il est créé avec succès, il est terminé.

À ce rythme, deux tâches (l'une démarrée depuis le terminal avec ecs-cli et l'autre démarrée par la création d'un service) sont en cours d'exécution, la première est donc arrêtée et OK. ..

Bonus (déploiement automatique en coopération avec CircleCi)

Si cela est laissé tel quel, à chaque fois qu'il y a un changement, il sera nécessaire d'effectuer manuellement un travail gênant tel que "build-> push-> task redefinition", donc un mécanisme commun tel que "push to CircleCi-> build & test-> automatic deployment to ECR / ECS" Continuera à construire.

Présentation de Rspec

Tout d'abord, introduisez Rspec pour les tests avant le déploiement.

Installer la gemme

./Gemfile

group :development, :test do
  gem 'rspec-rails'
end

#J'ai mis à jour le Gemfile, alors reconstruisez-le
$ docker-compose build

Créer et modifier divers fichiers

$ docker-compose run web bundle exec rails generate rspec:install

create  .rspec
create  spec
create  spec/spec_helper.rb
create  spec/rails_helper.rb

ruby:./.rspec

--format documentation

Si vous ajoutez une ligne de ↑, il sera plus facile de voir l'affichage de sortie lorsque Rspec est exécuté.

ruby:./spec/rails_helper.rb

Dir[Rails.root.join('spec', 'support', '**', '*.rb')].sort.each { |f| require f }

Bien que ce ne soit pas essentiel, si vous décidez de créer une méthode d'assistance pour les tests plus tard, "spec / support" sera utilisé comme emplacement de stockage pour le fichier, alors définissez-le pour le moment.

Par défaut, il est commenté, vous pouvez donc le supprimer.

ruby:./config/application.rb

config.generators do |g|
  g.test_framework :rspec, 
    view_specs: false, 
    helper_specs: false, 
    controller_specs: false, 
    routing_specs: false
end

Si cela reste tel quel, divers fichiers de test seront créés automatiquement lorsque vous tapez la commande rails g, donc si vous ne voulez pas en créer d'autres, définissez-le dans" config / application.rb ".

• Cette zone est votre choix.

Exécutez rspec

$ docker-compose run web bundle exec rspec

No examples found.

Finished in 0.00276 seconds (files took 0.12693 seconds to load)
0 examples, 0 failures

Je n'ai encore écrit aucun test, c'est donc bien sûr le cas.

Écrivons la spécification de demande pour le moment

Comme point de départ, écrivons une spécification de demande pour vérifier si une réponse normale est renvoyée à la demande.

Créer un fichier de test

$ docker-compose run web bundle exec rails g rspec:request home

create  spec/requests/homes_spec.rb

ruby:./spec/requests/home_spec.rb

require 'rails_helper'

RSpec.describe "Home", type: :request do
  describe "GET /" do
    it "works successfully" do
      get root_path
      expect(response).to have_http_status(200)
    end
  end
end

Un test pour voir si un code d'état de 200 est renvoyé lors de l'accès à "/".

$ docker-compose run web bundle exec rspec

Home
  GET /
    works successfully

Finished in 0.53664 seconds (files took 8.4 seconds to load)
1 example, 0 failures

Exécutez à nouveau rspec, et s'il réussit sans problème, il réussit.

Fonctionne avec CircleCI

Ensuite, définissez les paramètres de liaison avec CircleCi.

Installer la gemme

./Gemfile

group :development, :test do
  gem 'database_cleaner'
  gem 'rspec_junit_formatter'
  gem 'webdrivers', '~> 3.0'
end

#J'ai mis à jour le Gemfile, alors reconstruisez-le
$ docker-compose build

Créer et modifier divers fichiers

$ mkdir .circleci
$ touch .circleci/config.yml

$ touch config/database.yml.ci

$ docker-compose run web bundle exec rails db:schema:dump 

yml:./.circleci/config.yml

version: 2
jobs:
  build:
    docker:
    - image: circleci/ruby:2.6.6-node-browsers
      environment:
        - BUNDLER_VERSION: 2.1.4
        - RAILS_ENV: 'test'

    - image: circleci/mysql:5.7
      environment:
        - MYSQL_ALLOW_EMPTY_PASSWORD: 'true'
        - MYSQL_ROOT_HOST: '127.0.0.1'

    working_directory: ~/sample_app

    steps:
    - checkout

    - restore_cache:
        keys:
        - v1-dependencies-{{ checksum "Gemfile.lock" }}
        - v1-dependencies-

    - run:
        name: install dependencies
        command: |
          gem install bundler -v 2.1.4
          bundle install --jobs=4 --retry=3 --path vendor/bundle
    - save_cache:
        paths:
        - ./vendor/bundle
        key: v1-dependencies-{{ checksum "Gemfile.lock" }}

    # database setup
    - run: mv ./config/database.yml.ci ./config/database.yml

    # database setup
    - run:
        name: setup database
        command: |
           bundle exec rake db:create
           bundle exec rake db:schema:load
    
    # install yarn
    - run:
        name: install yarn
        command: yarn install

    # install webpack
    - run:
        name: install webpack
        command: bundle exec bin/webpack

    # run tests
    - run:
        name: run rspec
        command: |
          mkdir /tmp/test-results
          TEST_FILES="$(circleci tests glob "spec/**/*_spec.rb" | \
            circleci tests split --split-by=timings)"
          bundle exec rspec \
            --format progress \
            --format RspecJunitFormatter \
            --out /tmp/test-results/rspec.xml \
            --format progress \
            $TEST_FILES
    # collect reports
    - store_test_results:
        path: /tmp/test-results

    - store_artifacts:
        path: /tmp/test-results
        destination: test-results

yml:./config/database.yml.ci

test:
  adapter: mysql2
  encoding: utf8
  pool: 5
  username: 'root'
  port: 3306
  host: '127.0.0.1'
  database: sample_app_test

ruby:./spec/rails_helper.rb

RSpec.configure do |config|

  # config DataBaseCleaner
  config.before(:suite) do
    DatabaseCleaner.strategy = :transaction
    DatabaseCleaner.clean_with(:truncation)
    Rails.application.load_seed
  end

  config.before(:each) do
    DatabaseCleaner.start
  end

  config.after(:each) do
    DatabaseCleaner.clean
  end
end

ruby:./db/schema.rb

# This file is auto-generated from the current state of the database. Instead
# of editing this file, please use the migrations feature of Active Record to
# incrementally modify your database, and then regenerate this schema definition.
#
# This file is the source Rails uses to define your schema when running `rails
# db:schema:load`. When creating a new database, `rails db:schema:load` tends to
# be faster and is potentially less error prone than running all of your
# migrations from scratch. Old migrations may fail to apply correctly if those
# migrations use external dependencies or application code.
#
# It's strongly recommended that you check this file into your version control system.

ActiveRecord::Schema.define(version: 0) do

end

Connectez CircleCi et GitHub

https://app.circleci.com/projects/project-dashboard/github/GitHubのアカウント名/

↑ Recherchez le référentiel avec lequel vous souhaitez créer un lien dans le tableau de bord CircleCi et cliquez sur "Configurer le projet". Réglez selon les instructions affichées à l'écran.

Désormais, lorsque vous effectuerez un nouveau push vers GitHub à l'avenir, build & test s'exécutera automatiquement en fonction du contenu écrit dans ".circleci / config.yml".

S'il n'y a pas de problème, "SUCCESS" doit être affiché. Ceci termine les réglages initiaux.

Déploiement automatique (ECR / ECS)

À l'aide d'Orb ajouté à partir de la version 2.1 de CircleCi, lorsque des modifications sont apportées à la branche principale, créez et testez avec CircleCi, créez automatiquement une image et envoyez-la vers ECR, mettez à jour le service ECS et mettez à jour la tâche Essayez de redéfinir.

Enregistrement des variables d'environnement

Enregistrez à l'avance les variables d'environnement requises pour le déploiement à partir de l'écran de configuration CircleCi.

• AWS_ACCESS_KEY_ID
• La clé d'accès de l'utilisateur IAM créée précédemment
• AWS_SECRET_ACCESS_KEY
• La clé secrète de l'utilisateur IAM créée précédemment
• AWS_ACCOUNT_ID
• ID de compte AWS (peut être confirmé depuis "Mon compte" sur la console)
• AWS_REGION
  • ap-northeast-1
• AWS_ECR_ACCOUNT_URL
• URI du référentiel ECR (par exemple, .dkr.ecr.ap-Nord-Est-1.amazonaws.com)
• DATABASE_HOST --RDS endpoint (par exemple ********. Ap-northeast-1.rds.amazonaws.com)
• DATABASE_USERNAME --Nom d'utilisateur RDS (par exemple root)
• DATABASE_PASSWORD --RDS mot de passe (par exemple mot de passe)
• DATABASE_NAME --Nom de la base de données à utiliser (par exemple, sample_app_production)
• RAILS_MASTER_KEY --Valeur de config / master.key
• TZ
  • JAPAN
• MY_APP_PREFIX
• En option (par exemple, exemple d'application)
• Il est préférable de créer des noms de cluster et des noms de tâches comprenant des mots communs afin que les variables puissent être réutilisées et écrites de la manière la plus compacte possible (sample-app-cluster, sample-app-task, etc.).

Modifier .circleci / config.yml

yml:./.circleci/config.yml

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

jobs:
  test:
    docker:
      - image: circleci/ruby:2.6.6-node-browsers
        environment:
          - BUNDLER_VERSION: 2.1.4
          - RAILS_ENV: 'test'

      - image: circleci/mysql:5.7
        environment:
          - MYSQL_ALLOW_EMPTY_PASSWORD: 'true'
          - MYSQL_ROOT_HOST: '127.0.0.1'

    working_directory: ~/project

    steps:
      - checkout

      - restore_cache:
          keys:
          - v1-dependencies-{{ checksum "Gemfile.lock" }}
          - v1-dependencies-

      - run:
          name: install dependencies
          command: |
            gem install bundler -v 2.1.4
            bundle install --jobs=4 --retry=3 --path vendor/bundle

      - save_cache:
          paths:
          - ./vendor/bundle
          key: v1-dependencies-{{ checksum "Gemfile.lock" }}

      - run: mv ./config/database.yml.ci ./config/database.yml

      - run:
          name: setup database
          command: |
            bundle exec rake db:create
            bundle exec rake db:schema:load

      - run:
          name: install yarn
          command: yarn install

      - run:
          name: install webpack
          command: bundle exec bin/webpack

      - run:
          name: run rspec
          command: |
            mkdir /tmp/test-results
            TEST_FILES="$(circleci tests glob "spec/**/*_spec.rb" | \
              circleci tests split --split-by=timings)"
            bundle exec rspec \
              --format progress \
              --format RspecJunitFormatter \
              --out /tmp/test-results/rspec.xml \
              --format progress \
              $TEST_FILES

      - store_test_results:
          path: /tmp/test-results

      - store_artifacts:
          path: /tmp/test-results
          destination: test-results

workflows:
  version: 2
  test_and_deploy:
    jobs:
      - test
      #Poussez l'image vers ECR après la construction
      - aws-ecr/build-and-push-image:
          requires:
            - test
          account-url: AWS_ECR_ACCOUNT_URL
          region: AWS_REGION
          aws-access-key-id: AWS_ACCESS_KEY_ID
          aws-secret-access-key: AWS_SECRET_ACCESS_KEY
          create-repo: true
          dockerfile: ./prod.Dockerfile
          repo: "${MY_APP_PREFIX}-rails"
          tag: "${CIRCLE_SHA1}"
          filters:
            branches:
              only:
                - master
      #Mettre à jour les services ECS pour redéfinir les tâches
      - aws-ecs/deploy-service-update:
          requires:
            - aws-ecr/build-and-push-image
          family: "${MY_APP_PREFIX}-task"
          cluster-name: "${MY_APP_PREFIX}-cluster"
          service-name: "${MY_APP_PREFIX}-service"
          container-image-name-updates: "container=app,tag=${CIRCLE_SHA1}"

Assurez-vous que chaque variable d'environnement est correcte.

erb:./app/views/home/index.html.erb

<h1>Hello World!</h1>
<p>Completed auto deploy with CircleCi</p>

Modifiez un peu la page d'accueil pour voir si le déploiement automatique a fonctionné.

Apportez des modifications à la branche principale

Lorsque je le pousse vers la branche principale et que j'apporte des modifications, les tâches avec déploiement commencent à s'exécuter sur CircleCi.

`* Veuillez noter qu'il faut environ 10 à 15 minutes pour terminer tous les flux. ''

Accédez à nouveau au nom DNS de l'équilibreur de charge et si la modification précédente est correctement mise à jour, elle réussit.

`` * Cela prendra un certain temps avant que cela ne se reflète, alors attendez patiemment. ''

Deux tâches, une ancienne tâche et une nouvelle tâche, sont en cours d'exécution, mais l'ancienne sera effacée d'elle-même au fil du temps (grâce au service?), Vous pouvez donc la laisser telle quelle.

Je vous remercie pour votre travail acharné.

Épilogue

J'étudie toujours, donc je vais le mettre à jour chaque fois que j'ai quelque chose.

Actuellement, le travail effectué en déplaçant les mains sur la console et le travail effectué en appuyant sur des commandes sur le terminal sont confondus, je voudrais donc les unifier tous à ce dernier si possible.

Je veux pouvoir le faire en une seule fois avec Terraform.

Je vous serais reconnaissant si vous pouviez dire s'il y a quelque chose de coincé ou si quelque chose comme ça est mieux.

Partie personnellement bouchée

Type d'instance EC2

--Recommandé "t2.small" ou supérieur. Je pense que "t2.micro" est la norme lors de son utilisation dans le cadre libre, mais dans le cas de l'auteur, il y a eu un problème de mémoire insuffisante avec t2.micro.

service sample-app-service was unable to place a task because no container instance met all of its requirements. The closest matching container-instance c4b1a3e7-3209-408c-9501-7b3ea30f97f7 has insufficient memory available. For more information, see the Troubleshooting section.

Référence: https://aws.amazon.com/jp/premiumsupport/knowledge-center/ecs-container-instance-cpu-error/

Dans cet article, commandes lors de la création d'un cluster

$ ecs-cli up --keypair sample-app --capability-iam --size 2 --instance-type t2.small --cluster-config sample-app-cluster --ecs-profile sample-app

↑ Le type d'instance est spécifié dans cette partie.

Paramètres Nginx

--Le contenu du fichier nginx.conf ne fonctionne pas correctement à moins que vous ne les modifiiez, vous devez donc les modifier comme il convient lors de la recherche sur Google.

Si la connexion entre le conteneur d'application et le conteneur nginx ne fonctionne pas

2020/09/13 20:02:57 [crit] 7#7: *456 connect() to unix:///sample-app/tmp/sockets/puma.sock failed (2: No such file or directory) while connecting to upstream, client: *********, server: localhost, request: "GET / HTTP/1.1", upstream: "http://unix:///sample-app/tmp/sockets/puma.sock:/500.html", host: "***********"

↑ Je suis énervé à l'infini avec une erreur comme celle-ci.

Réglage de chaque variable d'environnement

--Il est préférable de vérifier plusieurs fois si les valeurs des variables d'environnement enregistrées dans CircleCi sont correctes. La construction prend beaucoup de temps, donc un seul échec est une énorme perte de temps.