[Für Super-Anfänger (mehr Squeeze)] Automatische Bereitstellung in AWS ECR / ECS mit Ruby2.6 x Rails6 x CircleCi [Hands-on-Format]

Konfiguration in diesem Artikel

① auf GitHub drücken ② Build läuft auf CircleCi ③ Wenn der Test (Rspec) bestanden wurde, erstellen Sie ein Docker-Image und senden Sie es an ECR. (4) Verwenden Sie das neueste Docker-Image, aktualisieren Sie die ECS-Aufgabendefinition und schließen Sie die Bereitstellung ab.

Zielgruppe

• Personen, die ECS noch nie berührt haben
• Menschen, die ihre Hände bewegen und ein Gefühl für die Atmosphäre bekommen wollen
• Personen, die ein Portfolio für die Jobsuche erstellen

Schritte zum Bereitstellen einer einfachen Rails-App (zeigen Sie einfach "Hallo Welt!" An) für AWS ECS. Bitte beachten Sie, dass wir den nachfolgenden Vorgang nicht berücksichtigen und nur als Referenz dienen.

Je nach Person gibt es wahrscheinlich verschiedene Möglichkeiten. Wenn Sie den Fluss erfasst haben, stellen Sie ihn bitte nach Ihren Wünschen ein.

Ab der Phase der Vorbereitung der Anwendung für die Bereitstellung wird alles im praktischen Format (viele Spieße) beschrieben. Wenn Sie wie beschrieben vorgehen, sollte dies grundsätzlich funktionieren.

Es gibt einen Teil, um an wichtigen Stellen beliebige Werte (Profilname, Anwendungsname usw.) festzulegen. Wenn Sie sich also nicht sicher sind, ist es möglicherweise besser, sich mit "Beispiel-App" usw. wie dem Autor zu vereinen.

`* Obwohl es für Anfänger gekennzeichnet ist, erklärt es nicht jeden Begriff, da es dem Zweck gewidmet ist," zuerst die Hände zu bewegen, um ein Gefühl für die Atmosphäre zu bekommen ". ``

* Das Konzept ist, dass selbst ein Super-Anfänger von AWS so bereitstellen kann, wenn Sie vorerst die Anweisungen befolgen. Es wird empfohlen, dass theoretische Studenten das Konzept von ECR / ECS in anderen Artikeln lernen, bevor sie eintreten. (Weil ich mich mit meinem Körper daran erinnere ...)

`* Jeder Ressourcenname von AWS ist grundsätzlich beliebig, sodass Sie ihn nach Belieben verwenden können (wenn Sie jedoch einen Befehl mit ecs-cli eingeben oder die Beschreibung in der CircleCi-Konfiguration übereinstimmen müssen). Auch für die Teile, die nicht besonders erwähnt werden, denke ich, dass der Standardzustand oder die Leerzeichen vorerst in Ordnung sind. ``

* Die Revisionsnummer kann aufgrund unterschiedlicher Zeitangaben variieren, aber bitte ignorieren Sie sie (Schweiß)

Spezifikation

• Sprache: Ruby2.6
• Rahmen: Rails6 --Datenbank: MySQL5.7
• Anwendungsserver: Puma
• Webserver: Nginx

Vorbereitung

Bereiten Sie zunächst eine einfache Rails-App für die Bereitstellung in ECS vor.

Stichprobe

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

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

installieren

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

#Wenn mit dem Befehl ↑ ein Fehler auftritt
$ docker-compose run web yarn install --check-files

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

Erstellen Sie master.key

Wenn Sie das Repository von ↑ geklont haben, sollte config / master.key nicht vorhanden sein. Wenn keine master.key vorhanden ist, tritt zum Zeitpunkt der Bereitstellung ein Fehler auf. Generieren Sie ihn daher hier gemäß dem folgenden Verfahren.

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

Referenz: Ich möchte Anmeldeinformationen mit Rails on Docker bearbeiten ActiveSupport::MessageEncryptor::InvalidMessage

Greifen Sie auf localhost zu

Wenn Sie auf "http: // localhost" zugreifen und der übliche Bildschirm angezeigt wird, ist dies in Ordnung.

Erstellt die Top-Seite "Hallo Welt!"

Erstellen Sie eine Top-Seite, die "Hello World!" Zurückgibt. Dies ist das Endziel dieser Zeit.

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

Wenn "Hello World!" Zurückgegeben wird, ist die Beispielanwendung bereit.

Bereitstellen

Nachdem die App fertig ist, stellen wir sie in ECS bereit.

Installieren Sie verschiedene Werkzeuge

Dieses Mal werden wir die folgenden zwei Tools für die Bereitstellung in ECS verwenden.

• AWS CLI
• Amazon ECS CLI

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

konfigurieren aws konfigurieren

Richten Sie aws configure so ein, dass die oben genannten Tools verwendet werden.

IAM-Benutzer erstellen

Wählen Sie in der AWS-Konsole Dienste → IAM aus und klicken Sie auf „Benutzer hinzufügen“.

Geben Sie einen beliebigen Benutzernamen ein (diesmal "Beispiel-App"), aktivieren Sie "Zugriff per Programm" und fahren Sie mit dem nächsten Schritt fort.

Fügen Sie unter "Vorhandene Richtlinie direkt anhängen" die folgenden beiden Richtlinien zum nächsten Schritt hinzu.

• AmazonECS_FullAccess
• AmazonEC2ContainerRegistryFullAccess

Ignorieren Sie diesmal die Tags und fahren Sie mit dem nächsten Schritt fort.

Schließlich wird ein Bestätigungsbildschirm für Eingabeinformationen angezeigt. Wenn also keine besonderen Probleme auftreten, klicken Sie auf "Benutzer erstellen".

Wenn es Ihnen gelingt, einen Benutzer zu erstellen, erhalten Sie einen "Zugriffsschlüssel" und einen "geheimen Zugriffsschlüssel". Machen Sie sich also Notizen oder laden Sie die CSV-Datei herunter und bewahren Sie sie an einem sicheren Ort auf.

Führen Sie "aws configure" im Terminal aus

$ aws configure --profile <Der zuvor erstellte IAM-Benutzername (diesmal "Beispiel")-app」）>

AWS Access Key ID #Der zuvor erstellte Zugriffsschlüssel
AWS Secret Access Key #Der geheime Zugriffsschlüssel, den Sie zuvor erstellt haben
Default region name # ap-northeast-1 
Default output format # json 

Geben Sie jeweils wie oben ein.

Erstellen Sie zusätzliche Richtlinien

Als ich den IAM-Benutzer früher erstellt habe

• AmazonECS_FullAccess
• AmazonEC2ContainerRegistryFullAccess

Ich habe zwei Richtlinien angehängt, aber dies allein führt zu einem Berechtigungsfehler im Tool "ecs-cli", der später verwendet wird. Daher muss ich ihn hier separat hinzufügen.

Wählen Sie in der AWS-Konsole Dienste → IAM → Richtlinien aus und klicken Sie auf Richtlinie erstellen.

Öffnen Sie die Registerkarte JSON und schreiben Sie Folgendes.

{
    "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": "*"
        }
    ]
}

Geben Sie einen Namen und eine Beschreibung der Richtlinie ein und klicken Sie auf "Richtlinie erstellen".

Richtlinie an Benutzer anhängen

Wählen Sie in der AWS-Konsole Dienste → IAM → Benutzer aus und klicken Sie auf "Zugriff hinzufügen".

Wählen Sie die zuvor erstellte Richtlinie unter "Vorhandene Richtlinie anhängen" aus und fügen Sie die Zugriffsberechtigung hinzu.

Erstellen Sie ein Schlüsselpaar

Erstellen Sie ein Schlüsselpaar, wie Sie es später bei der Eingabe von EC2 benötigen.

Wählen Sie in der AWS-Konsole Dienste → EC2 → Schlüsselpaar aus und klicken Sie auf „Schlüsselpaar erstellen“.

Geben Sie den Namen und das Dateiformat ein und klicken Sie auf "Schlüsselpaar erstellen".

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

Wenn Sie fertig sind, wird eine Datei im ".pem" -Format heruntergeladen. Verschieben Sie sie in das Verzeichnis ".ssh" und ändern Sie die Berechtigungen.

Erstellen Sie einen Cluster

Es ist möglich, es manuell über die Konsole zu erstellen. Da es jedoch erforderlich ist, vpc und Subnetz zusammen zu erstellen, wird es diesmal gemeinsam mit ecs-cli erstellt.

Führen Sie den folgenden Befehl aus.

$ ecs-cli configure profile --profile-name <Beliebiger Profilname> --access-key <Der zuvor erstellte Zugriffsschlüssel> --secret-key <Der geheime Zugriffsschlüssel, den Sie zuvor erstellt haben>
$ ecs-cli configure --cluster <Beliebiger Clustername> --default-launch-type EC2 --config-name <Beliebiger Einstellungsname> --region ap-northeast-1
$ ecs-cli up --keypair <Das zuvor erstellte Schlüsselpaar> --capability-iam --size 2 --instance-type t2.samll --cluster-config <Beliebiger Einstellungsname> --ecs-profile <Beliebiger Profilname>

Jeder Wert wie ein Schlüssel ist anders. Im Fall des Autors sieht es wie folgt aus.

$ 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.

Wenn alles gut geht, werden VPCs, Sicherheitsgruppen, Subnetze usw. für den Cluster automatisch erstellt, wie in ↑ gezeigt.

Wählen Sie in der AWS-Konsole Service-> Elastic Container Service-> Cluster aus. Wenn es erfolgreich erstellt wurde, ist es erfolgreich.

RDS erstellen

Erstellen Sie ein RDS, das als Datenbank verwendet werden soll.

Wählen Sie in der AWS-Konsole Dienste → RDS aus und klicken Sie auf "Datenbank erstellen".

--Erstellungsmethode: Standarderstellung

• Motortyp: MySQL
• DB-Instanzgröße: Freie Schicht

--DB-Instanzkennung: sample-app-db

• Master-Benutzername: root
• Passwort: Passwort

`* Dieser Bereich ist optional. ``

--vpc: Der zuvor erstellte vpc --Subnetzgruppe: Erstellen Sie eine neue DB-Subnetzgruppe

• Öffentlicher Zugang: Ja

`* Da dies eine Praxis ist, habe ich" Ja "ausgewählt, aber in einer Produktionsumgebung ist es möglicherweise besser, sie auf" Nein "zu setzen. ``

Erster Datenbankname: sample_app_production

`* Bei Verwendung des am Anfang des Artikels vorbereiteten Beispiels (Beispiel-App) * Da der Datenbankname in" config / database.yml "der Beispiel-App definiert ist, ist er auf" sample_app_production "festgelegt

`* Leer lassen oder Standard für unberührte Teile. ``

Wenn es kein Problem gibt, klicken Sie auf "Datenbank erstellen".

↑ Erfolg, wenn es so erstellt wird.

Sie müssen auch eine Sicherheitsgruppe festlegen. Klicken Sie daher auf den Link unter "VPC-Sicherheitsgruppe".

Stellen Sie Folgendes unter "Eingehende Regel bearbeiten" ein.

--Typ: MYSQL / Aurora --Protokoll: TCP

• Portbereich
• Quelle: 0.0.0.0/0

$ mysql -h <RDS-Endpunkt> -u <RDS-Benutzername> -p

Versuchen Sie, den Befehl ↑ im Terminal zu drücken. Wenn Sie eine Verbindung herstellen können, sind Sie erfolgreich.

Erstellen Sie einen Load Balancer

Wählen Sie in der AWS-Konsole Dienste → EC2 → Load Balancer aus und klicken Sie auf „Load Balancer erstellen“.

Es gibt drei Typen, aber wählen Sie "Application Load Balancer".

--Name: sample-app-alb * Optional

• Listener: OK wie es ist --VPC: Wählen Sie die zuvor automatisch erstellte aus --subzone: Wie oben

Wenn Sie fortfahren, wird der Einstellungsbildschirm für Sicherheitsgruppen angezeigt. Erstellen Sie daher unter "Neue Sicherheitsgruppe erstellen" eine entsprechende Sicherheitsgruppe.

Zielgruppeneinstellungen.

• Zielgruppe: Neue Zielgruppe --Name: sample-app-alb-tg * Optional

Registrieren Sie den EC2, der beim Erstellen des Clusters automatisch erstellt wurde. Wenn im Bestätigungsbildschirm keine Probleme auftreten, klicken Sie zum Abschluss auf "Erstellen".

Schieben Sie das Docker-Image auf ECR

Wählen Sie in der AWS-Konsole Dienste → Amazon Elastic Container Registry aus und klicken Sie auf "Repository erstellen".

Geben Sie jeweils einen geeigneten Repository-Namen ein und klicken Sie auf "Repository erstellen".

Zeigen Sie den Push-Befehl an und führen Sie die vier in der angegebenen Reihenfolge von oben aus.

• Wenn Sie mit dem zweiten Befehl erstellen, ändern Sie den Kontext der Docker-Datei mit -f.

#Schienen (Produktions-Dockerfile verwenden)
$ docker build -f ./prod.Dockerfile . -t sample-app-rails 

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

Dockerfile für die Produktion

$ 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

#Vorbereitung auf die Kommunikation mit 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

Es ist im Grunde dasselbe wie das für die Entwicklung, aber die letzten Zeilen bereiten die Kommunikation mit Nginx vor.

Nachdem Sie alles eingegeben haben, überprüfen Sie das Repository. Wenn das Bild hinzugefügt wird, ist es erfolgreich.

Eine Aufgabe erstellen

Erstellen Sie eine Aufgabe basierend auf dem Bild, das Sie zuvor gepusht haben.

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

yml:./ecs/docker-compose.yml

version: 2
services:
  app:
    image: #ECR-Repository-URI (Rails)
    command: bash -c "bundle exec rails db:migrate && bundle exec rails assets:precompile && bundle exec puma -C config/puma.rb"
    environment: #Es ist eine Übung, also ein direkter Schreibstil, aber ich denke, es ist tatsächlich besser, dotenv zu verwenden.
      RAILS_ENV: production
      RAILS_MASTER_KEY: # config/master.Wert des Schlüssels
      DATABASE_NAME: sample_app_production
      DATABASE_USERNAME: root
      DATABASE_PASSWORD: password
      DATABASE_HOST: #RDS-Endpunkt
      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: #ECR-Repository-URI (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

Führen Sie den folgenden Befehl aus.

$ 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

Bei Erfolg wird eine "1" für die laufende Aufgabe angezeigt.

Zum Schluss können Sie den DNS-Namen des Load Balancers in die URL einfügen.

Erfolg, wenn "Hallo Welt!" Auf die gleiche Weise angezeigt wird wie die in der lokalen Umgebung erstellte.

• Wenn während der Bereitstellung ein Fehler auftritt, überprüfen Sie das CloudWatch-Protokoll und beheben Sie es.

Einen Service erstellen

Die App funktioniert nur mit dem Cluster und der Aufgabe. Wenn Sie jedoch in der Mitte einen sogenannten "Dienst" erstellen, wird sie neu gestartet, wenn der Container stoppt, oder sie wird automatisch über den Load Balancer skaliert. Deshalb habe ich sie erstellt, weil sie praktisch ist. Behalte es.

Klicken Sie in der AWS-Konsole auf Dienste → Amazon Elastic Container Service → Clustername, um die Registerkarte Dienste zu öffnen und zur Seite Erstellen zu wechseln.

• Starttyp: EC2
• Aufgabenaufgabe: Beispiel-App-Aufgabe * Die zuvor erstellte --Cluster: sample-app-cluster * Wie oben --Service-Name: Beispiel-App-Service * Optional
• Sonstiges: Wie im Bild gezeigt

• Load Balancer-Typ: Application Load Balancer --Road Balancer Name: Was Sie zuvor erstellt haben
• Sonstiges: Wie im Bild gezeigt

--Zielgruppenname: Was Sie zuvor erstellt haben

• Sonstiges: Wie im Bild gezeigt

Am Ende wird ein Bestätigungsbildschirm angezeigt. Wenn also keine Probleme auftreten, klicken Sie auf Erstellen.

Wenn es erfolgreich erstellt wurde, ist es abgeschlossen.

Bei dieser Geschwindigkeit werden zwei Aufgaben ausgeführt (eine vom Terminal mit ecs-cli gestartet und die andere durch Erstellen eines Dienstes gestartet), sodass die erstere gestoppt und in Ordnung ist. ..

Bonus (automatische Bereitstellung in Zusammenarbeit mit CircleCi)

Wenn dies unverändert bleibt, müssen bei jeder Änderung manuell mühsame Arbeiten wie "Build-> Push-> Task-Neudefinition" ausgeführt werden, sodass ein gängiger Mechanismus wie "Push to CircleCi-> Build & Test-> Automatische Bereitstellung für ECR / ECS" erforderlich ist. Wird weiter bauen.

Einführung von Rspec

Führen Sie zunächst Rspec zum Testen vor der Bereitstellung ein.

Installieren Sie gem

./Gemfile

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

#Ich habe das Gemfile aktualisiert, also baue es erneut
$ docker-compose build

Erstellen und bearbeiten Sie verschiedene Dateien

$ 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

Wenn Sie eine Zeile ↑ hinzufügen, ist die Ausgabeanzeige bei Ausführung von Rspec einfacher zu sehen.

ruby:./spec/rails_helper.rb

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

Obwohl dies nicht unbedingt erforderlich ist, wird "spec / support" als Speicherort für die Datei verwendet, wenn Sie eine Hilfsmethode zum späteren Testen erstellen möchten. Legen Sie sie daher vorerst fest.

Standardmäßig ist es auskommentiert, sodass Sie es entfernen können.

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

Wenn dies unverändert bleibt, werden beim Testen des Befehls "Rails g" automatisch verschiedene Testdateien erstellt. Wenn Sie also keine zusätzlichen erstellen möchten, legen Sie diese in "config / application.rb" fest.

• Dieser Bereich ist Ihre Wahl.

Führen Sie rspec aus

$ 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

Ich habe noch keine Tests geschrieben, also ist dies natürlich der Fall.

Lassen Sie uns vorerst Request Spec schreiben

Schreiben wir als Ausgangspunkt eine Anforderungsspezifikation, um zu überprüfen, ob eine normale Antwort auf die Anforderung zurückgegeben wird.

Erstellen Sie eine Testdatei

$ 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

Ein Test, um festzustellen, ob beim Zugriff auf "/" der Statuscode 200 zurückgegeben wird.

$ 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

Führen Sie rspec erneut aus, und wenn es ohne Probleme erfolgreich ist, ist es erfolgreich.

Funktioniert mit CircleCI

Nehmen Sie als Nächstes die Einstellungen für die tatsächliche Verknüpfung mit CircleCi vor.

Installieren Sie gem

./Gemfile

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

#Ich habe das Gemfile aktualisiert, also baue es erneut
$ docker-compose build

Erstellen und bearbeiten Sie verschiedene Dateien

$ 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

Verbinden Sie CircleCi und GitHub

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

↑ Suchen Sie im CircleCi-Dashboard das Repository, mit dem Sie eine Verknüpfung herstellen möchten, und klicken Sie auf "Projekt einrichten". Stellen Sie die Einstellungen gemäß den Anweisungen auf dem Bildschirm ein.

Wenn Sie in Zukunft einen neuen Push für GitHub durchführen, wird build & test automatisch basierend auf den in ".circleci / config.yml" geschriebenen Inhalten ausgeführt.

Wenn es kein Problem gibt, sollte "SUCCESS" angezeigt werden. Damit sind die Grundeinstellungen abgeschlossen.

Automatische Bereitstellung (ECR / ECS)

Verwenden Sie Orb, das ab Version 2.1 von CircleCi hinzugefügt wurde. Wenn Änderungen am Hauptzweig vorgenommen werden, erstellen und testen Sie mit CircleCi, erstellen Sie automatisch ein Image und senden Sie es an ECR, aktualisieren Sie den ECS-Dienst und aktualisieren Sie die Aufgabe Versuchen Sie neu zu definieren.

Registrierung von Umgebungsvariablen

Registrieren Sie die für die Bereitstellung erforderlichen Umgebungsvariablen im Voraus auf dem CircleCi-Einstellungsbildschirm.

• AWS_ACCESS_KEY_ID
• Der Zugriffsschlüssel des zuvor erstellten IAM-Benutzers
• AWS_SECRET_ACCESS_KEY
• Der geheime Schlüssel des zuvor erstellten IAM-Benutzers
• AWS_ACCOUNT_ID --AWS-Konto-ID (kann über "Mein Konto" auf der Konsole bestätigt werden)
• AWS_REGION
  • ap-northeast-1
• AWS_ECR_ACCOUNT_URL --ECR-Repository-URI (z. B. .dkr.ecr.ap-northeast-1.amazonaws.com)
• DATABASE_HOST --RDS-Endpunkt (z. B. ********. Apnortheast-1.rds.amazonaws.com)
• DATABASE_USERNAME --RDS Benutzername (zB root)
• DATABASE_PASSWORD --RDS Passwort (zB Passwort)
• DATABASE_NAME
• Zu verwendender Datenbankname (z. B. sample_app_production)
• RAILS_MASTER_KEY --Wert von config / master.key
• TZ
  • JAPAN
• MY_APP_PREFIX --Optional (zB Sample-App)
• Es ist besser, Clusternamen und Aufgabennamen einschließlich allgemeiner Wörter zu erstellen, damit Variablen so kompakt wie möglich wiederverwendet und geschrieben werden können (Beispiel-App-Cluster, Beispiel-App-Aufgabe usw.).

Bearbeiten Sie .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
      #Schieben Sie das Bild nach dem Erstellen auf ECR
      - 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
      #Aktualisieren Sie die ECS-Dienste, um Aufgaben neu zu definieren
      - 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}"

Stellen Sie sicher, dass jede Umgebungsvariable korrekt ist.

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

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

Ändern Sie die Startseite ein wenig, damit Sie sehen können, ob die automatische Bereitstellung funktioniert hat.

Nehmen Sie Änderungen am Hauptzweig vor

Wenn ich es tatsächlich in den Hauptzweig schiebe und Änderungen vornehme, werden die Jobs mit Bereitstellung auf CircleCi ausgeführt.

`* Bitte beachten Sie, dass es ungefähr 10 bis 15 Minuten dauert, bis alle Abläufe abgeschlossen sind. ``

Greifen Sie erneut auf den DNS-Namen des Load Balancers zu. Wenn die vorherige Änderung ordnungsgemäß aktualisiert wurde, ist sie erfolgreich.

`* Es wird einige Zeit dauern, bis es reflektiert wird. Warten Sie also geduldig. ``

Zwei Aufgaben, eine alte und eine neue Aufgabe, werden ausgeführt, aber die alte Aufgabe wird im Laufe der Zeit von selbst gelöscht (dank des Dienstes?). Sie können sie also so lassen, wie sie ist.

Danke für deine harte Arbeit.

Nachwort

Ich lerne noch, also werde ich es aktualisieren, wenn ich etwas habe.

Gegenwärtig sind die Arbeit beim Bewegen der Hände auf der Konsole und die Arbeit beim Drücken von Befehlen auf dem Terminal verwechselt, daher möchte ich, wenn möglich, alle mit letzteren vereinheitlichen.

Ich möchte es mit Terraform auf einmal schaffen.

Ich wäre Ihnen dankbar, wenn Sie einen Kommentar abgeben könnten, wenn etwas stecken bleibt oder so etwas besser ist.

Persönlich verstopfter Teil

EC2-Instanztyp

• Empfohlen "t2.small" oder höher. Ich denke, dass "t2.micro" der Standard ist, wenn es im freien Frame verwendet wird, aber im Fall des Autors gab es ein Problem, dass der Speicher mit t2.micro nicht mehr ausreichte.

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.

Referenz: https://aws.amazon.com/jp/premiumsupport/knowledge-center/ecs-container-instance-cpu-error/

In diesem Artikel Befehle beim Erstellen eines Clusters

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

↑ In diesem Teil wird der Instanztyp angegeben.

Nginx-Einstellungen

• Der Inhalt der Datei nginx.conf funktioniert nur dann ordnungsgemäß, wenn Sie ihn ändern. Sie müssen ihn daher beim Googeln entsprechend ändern.

Wenn die Verbindung zwischen dem App-Container und dem Nginx-Container nicht funktioniert

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: "***********"

↑ Ich ärgere mich endlos über einen solchen Fehler.

Einstellung jeder Umgebungsvariablen

• Es ist besser, mehrmals zu überprüfen, ob die Werte der in CircleCi registrierten Umgebungsvariablen korrekt sind. Das Erstellen nimmt viel Zeit in Anspruch, daher ist ein einzelner Fehler eine enorme Zeitverschwendung.