[Teil 2] Testen und Bereitstellen von WEB-Diensten, die mit Rails + Nuxt + MySQL + Docker mit ECS / ECR / CircleCI erstellt wurden, automatisch für Terraform

Beim Schreiben dieses Artikels

Das Erstellen eines Portfolios aus einem Zustand, in dem ich keine Kenntnisse über AWS hatte, die persönliche Bereitstellung in AWS und die automatische Bereitstellung von CircleCI waren am schwierigsten. Daher ein Memorandum. Ich werde von nun an ein Portfolio erstellen. Für diejenigen, die AWS von nun an verwenden Ich dachte, es wäre schön, wenn es einen Artikel gäbe.

Eine Übersicht über das von mir erstellte Portfolio [AWS? Docker?] Fassen Sie die erforderlichen Kenntnisse in Ihrem Portfolio auf leicht verständliche Weise zusammen. [Terraform? CircleCI?]

Der Vorgänger dieses Artikels ist [Teil 1] Testen / Bereitstellen eines mit Rails + Nuxt + MySQL + Docker mit ECS / ECR / CircleCI erstellten WEB-Dienstes und Konvertieren in Terraform

Ich würde mich freuen, wenn Sie einen Blick darauf werfen könnten.

Erstens: [Teil 1] Automatische Bereitstellung und Terraformierung von WEB-Diensten, die mit Rails + Nuxt + MySQL + Docker mit ECS / ECR / CircleCI erstellt wurden 2. Dieser Artikel Drittens: [Teil 2] Stellen Sie den mit Rails + Nuxt + MySQL + Docker erstellten WEB-Dienst automatisch mit ECS / ECR / CircleCI bereit und machen Sie ihn terraform

Ziele für diesen Artikel

• Sie können grundlegende Netzwerkeinstellungen wie VPC, IGW, Subnetz, Routentabelle und Sicherheitsgruppe vornehmen.
• Sie können einen WEB-Dienst erstellen, der eine konstante SSL-Kommunikation über Route53, ACM und ALB ermöglicht.
• Kann mit ECS / ECR in einer Produktionsumgebung bereitgestellt werden.
• Sie können CircleCI verwenden, um gleichzeitig zu pushen und automatisch bereitzustellen.

Annahme

• Erhaltenes AWS-Konto / IAM-Konto / Schlüsselpaar (Sie sollten dies sofort tun können) --Aws-cli ist installiert
• Die verwendete Region ist Tokio (ap-Nordosten-1)
• Wir fahren mit der Implementierung bis zum vorherigen Artikel fort.
  [Teil 1] Testen / Bereitstellen eines mit Rails + Nuxt + MySQL + Docker mit ECS / ECR / CircleCI erstellten WEB-Dienstes und Konvertieren in Terraform

Fertiges Produkt

qiita-sample-app

Hinweis

Was Sie mit diesem Artikel tun können, wird normalerweise über die kostenlose AWS-Stufe hinaus ** bezahlt **. Da Sie eine Domain mit Ihrem name.com erhalten, kostet dies auch ** Geld. ** ** ** Bitte lesen Sie nur diejenigen, die denken, dass es sich um eine Studiengebühr handelt und diese aufteilen kann. Vorerst möchte ich einen lose gekoppelten Webdienst mit ECS und ECR veröffentlichen! Für diejenigen, die sagen.

Aufbau eines Netzwerks

Zunächst erstellen wir ein Netzwerk auf dem AWS-Bildschirm. Lassen Sie uns begeistert sein!

VPC-Erstellung

Bohnenwissen

Der CIDR-Block ist eine Abkürzung für Classless Inter-Domain Routing. Eine der Notationsmethoden für die IP-Adresse. Einfach gesagt, es ist die Palette der VPCs.

Hier ist es übrigens ein Display wie / 16. In der CIDR-Notation werden Notationen wie "/ 16", "/ 24" und "32" verwendet.

/ 16 kann bis zum dritten Oktett angeben. Zum Beispiel die "0.0" von 10.20.0.0 Sie können diesen Teil angeben.

/ 24 kann bis zum 4. Oktett angeben. Zum Beispiel die letzte "0" von 10.20.0.0 Sie können diesen Teil angeben.

/ 32 kann eine bestimmte IP-Adresse angeben.

Wenn Sie eine VPC erstellen, müssen Sie eine IP im Subnetz oder in AZ sichern, und die Änderung funktioniert nicht Geben Sie in vielen Fällen "/ 16" an, um viele verfügbare IPs zu sichern.

Subnetz erstellen

Hier verwenden wir AZ ** ap-nordöstlich-1a und ap-nordöstlich-1c **. Der Grund für die Verwendung der beiden AZs ist, dass wir ALB später verwenden werden.

Erstellen Sie das folgende Subnetz unter U-Boot> Unterabschnitt erstellen.

Erstellen einer Routentabelle

Erstellen Sie die folgende Routentabelle über Routentabelle> Routentabelle erstellen.

IGW erstellen

Erstellen Sie das folgende Internet-Gateway über Internet-Gateway> Internet-Gateway erstellen.

Assoziieren Sie VPC und IGW.

Zuordnung von Subnetz und Routentabelle

--Wählen Sie die Registerkarte Bearbeiten der Routentabelle und ordnen Sie das zuvor erstellte IGW 0.0.0.0 für die andere Routentabelle als RDS zu. --Wählen Sie die Registerkarte U-Boot-Zuordnung und ordnen Sie sie wie in der folgenden Tabelle gezeigt zu

Erstellen einer Sicherheitsgruppe

Erstellen Sie eine Sicherheitsgruppe in der folgenden Tabelle

Dies ist das Ende des Netzwerks.

Erstellung von Route53 (von hier aus berechnet)

Eine Domain erhalten

Holen Sie sich die Domain von Name.com. Bitte geben Sie die Domain an, die Ihnen gefällt (vorzugsweise 1 Yen) und die auf diesen Artikel verweist.

Informationen zum Abrufen einer Domain mit Ihrem name.com finden Sie unter [Abrufen einer Domain] Abrufen einer Domain mit Ihrem name.com und aws.

** * Deaktivieren Sie die automatische Domain-Update-Einstellung! (Es kostet jedes Jahr Geld) **

Dieses Mal habe ich in meiner Umgebung die folgenden Domänen erhalten.

Erstellen einer gehosteten Zone

Erstellen Sie eine Hostzone aus Route53.

Kopieren Sie aus den Details der Hostzone den ** Wert / das Verkehrsroutingziel ** des NS-Datensatzes.

Registrieren Sie den Wert des NS-Datensatzes auf dem Nameserver Ihres name.com

Das Nachdenken wird einige Zeit dauern. (Es kann bis zu 1 Tag dauern)

dig qiita-sample.work(Erworbene Domain) +short NS

Wird vom Terminal eingegeben und wenn der erfolgreich registrierte NS-Datensatz angezeigt wird, wird er angezeigt.

Stellen Sie mithilfe von ACM ein Zertifikat an eine Domäne aus

Fordern Sie ein Zertifikat bei ACM an. Wählen Sie Öffentliches Zertifikat anfordern, um ein Zertifikat anzufordern.

Geben Sie den obigen Domainnamen ein und wählen Sie DNS-Validierung. Machen Sie dasselbe für qiita-sample-api.work.

Anschließend werden Sie zum Überprüfungsbildschirm weitergeleitet, auf dem Sie ** einen Datensatz mit Route53 erstellen **. (Erstellen Sie Datensätze in allen oben genannten Domänen.) Nach einer Weile steht die Überprüfung noch aus und der Status wird veröffentlicht. Wenn die Überprüfung längere Zeit ansteht, ist es möglich, dass sich die Einstellungen des NS-Servers verzögern. Lassen Sie uns mit dem Befehl dig überprüfen.

RDS erstellen

Das Einrichten von Route53 und des Domain Name Servers dauert einige Zeit. Erstellen Sie daher hier schnell RDS.

Erstellen einer Subnetzgruppe

RDS-Erstellung / Konfiguration

Erstellen Sie RDS, indem Sie RDS> Datenbank erstellen auswählen und dabei die folgenden Einstellungen beachten.

Nach einer Weile ist es verfügbar, und die RDS-Erstellung ist abgeschlossen.

Änderung von database.yml und 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 

Dann erscheint der vim-Bildschirm. Geben Sie die folgenden Einstellungen ein.

rds:
  host: {Endpunkt}
  database: {Datenbankname (früh erstellt)}
  username: {Benutzernamen festlegen}
  password: {Passwort festlegen}

Erstellen eines Load Balancers

Erstellen wir einen Load Balancer über EC2> Create Load Balancer.

Load Balancer-Einstellungen

front

back Registrieren Sie die zuvor erstellte VPC und das Subnetz in der Verfügbarkeitszone.

Konfiguration der Sicherheitseinstellungen

Wählen Sie das zuvor erstellte Zertifikat aus. Wenn Sie noch nicht zertifiziert wurden, warten Sie eine Minute.

Sicherheitsgruppeneinstellungen

Bitte hängen Sie die zuvor erstellte Sicherheitsgruppe an.

Routing-Einstellungen

Erstellen Sie eine neue Zielgruppe. Diesmal vorne, um im von ECS generierten EC2 im ** Host-Modus ** zu starten Setzen Sie das Ziel auf die Instanz und akzeptieren Sie den Port auf 3000. Im Hintergrund ist das Ziel IP, da es in der Instanz von ECS im ** awsvpc-Modus ** im Container startet. Dies bezieht sich auf die private IP des Containers.

front

back

Zielregistrierung

Wie wir später sehen werden, keine Sorge, das Ziel wird automatisch ausgewählt, wenn der ECS-Dienst gestartet wird. Lassen Sie uns einen Road Balancer erstellen, wie er ist!

Ein Datensatz wurde zu Route53 hinzugefügt

Fügen Sie unter Route53> Hostzone einen Datensatz hinzu und stellen Sie ihn wie folgt ein. Bitte bearbeiten Sie Vorder- und Rückseite auf die gleiche Weise.

Erstellen Sie ein Repository in ECR / Push-Image

Lassen Sie uns die Ausrichtung der Front-API für die Produktion ändern.

js:./front/plugins/axios.js

import axios from "axios"

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

** * Lass uns aws cli zur Verfügung stellen! ** ** ** Installieren Sie AWS CLI Version 1 unter macOS AWS CLI installieren

Erstellen Sie ein Repository aus Amazon ECR. Bitte geben Sie den Repository-Namen ein und erstellen Sie ihn so wie er ist. Wählen Sie ein Repository aus und drücken Sie den Befehl push, um die Befehle anzuzeigen, die an das Repository gesendet werden sollen. Erstellen Sie ein Repository für Vorder- und Rückseite und führen Sie es in der lokalen Umgebung aus.

Wenn Sie diese Befehle ausführen, wird ein Image basierend auf der Docker-Datei im Verzeichnis erstellt. Es befindet sich in demselben Zustand wie beim Erstellen von Docker-Compose in der lokalen Umgebung. Laden Sie das hier erstellte und auf ECR übertragene Bild in ECS und starten Sie es.

Bitte beachten Sie, dass Sie vor der Ausführung überprüfen sollten, welches Repository Sie an ** vorne oder hinten verschieben möchten, und dann in das Verzeichnis wechseln sollten, in dem sich die Docker-Datei befindet. ** ** **

ECS-Erstellung / Einstellung

Gesamtbild

In ECS Cluster> Dienste> Aufgaben Es ist die Korngröße geworden. Ein Cluster ist ein logischer Rahmen, eine Box. Der Dienst ähnelt der automatischen Skalierung + ALB, die im Cluster gestartet wird. Verwalten Sie automatisch die Anzahl der Aufgaben und konfigurieren Sie die Netzwerkeinstellungen. Stellen Sie sich eine Aufgabe als eine Einheit vor, die ein Docker-Image ausführt.

Der Dienst erstellt Aufgaben basierend auf der Aufgabendefinition. Der Taiyaki-Schimmel ist eine Dienstleistung, und der Taiyaki selbst ist wie eine Aufgabe. Der Cluster ist der Stand eines Taiyaki-Shops.

Erstellen eines ECS-Clusters

Diesmal habe ich mich für EC2 Linux + Networking entschieden

Wählen Sie für das Netzwerk die zuvor erstellte VPC / das Subnetz (Front) aus. Wählen Sie außerdem Aktiviert für Automatische Zuweisung öffentlicher IP-Adressen. Stellen Sie das Schlüsselpaar so ein, dass Sie eine Verbindung mit ssh herstellen können.

Amazon EC2-Schlüsselpaare und Linux-Instanzen

Wenn die EC2-Instanz nach dem Erstellen des Clusters wie unten gezeigt gestartet wird, ist sie erfolgreich. Gute Sache Wenn EC2-Instanzen nicht gebunden sind, sind Sicherheitsgruppen und Routentabellen häufig das Problem.

Erstellen einer Aufgabendefinition

Wählen Sie Neue Aufgabendefinition aus ECS erstellen

Wählen Sie EC2

front

back

Einen Service erstellen

Erstellen Sie einen Dienst aus dem Dienst-Tag des Clusters.

front

Wählen Sie für den Lastausgleich Application Load Balancer aus und wählen Sie den zuvor erstellten ALB und das Ziel aus.

back

Wählen Sie in der Netzwerkkonfiguration die zuvor erstellte Sicherheitsgruppe für VPC und Back-Subnetz aus. Wählen Sie für den Lastausgleich Application Load Balancer aus und wählen Sie den zuvor erstellten ALB und das Ziel aus.

Starten Sie den ECS-Dienst

Einmal wie oben erstellt, sollte eine Aufgabe automatisch hinzugefügt werden. Wenn es wie folgt aussieht, ist es in Ordnung! Der Container sollte innerhalb von EC2 sicher vom Image aus gestartet worden sein.

db:migrate Sie können eine Aufgabendefinition erstellen und die Aufgabe ausführen, aber dieses Mal werde ich eine SSH-Verbindung zur EC2-Instanz herstellen, dann in den Docker-Container gehen und "Rails DB: Migrate" versuchen. Ursprünglich musste ich eine Datenbank erstellen (db: create), aber dieses Mal habe ich RDS zum Zeitpunkt der Erstellung als Produktion in der ursprünglichen Datenbank festgelegt. Dies ist nicht erforderlich, da es bereits erstellt wurde.

[Pem-Datei 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 {PEM-Dateipfad} ec2-user@{Öffentliche IP der Instanz}


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

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

In einer EC2-Instanz

docker ps

Zeigt den aktuell ausgeführten Container an. Geben Sie die CONTAINER-ID der Container-Laufschienen an und geben Sie den folgenden Befehl ein, um sie in den Docker-Container einzufügen.

In einer EC2-Instanz

docker exec -it {CONTAINER ID} sh

Geben Sie hier die Umgebung und db an: migrate!

Im Docker-Container

rails db:migrate RAILS_ENV=production

Bestätigung starten

Danke für deine harte Arbeit!

ttps: // www. {Von mir selbst festgelegte Frontdomäne} / users Es ist in Ordnung, wenn Sie sowohl auf den Benutzer als auch auf den lokalen Benutzer zugreifen und ihn registrieren können (siehe Abbildung unten). ttps: // www. {Von mir festgelegte Back-Domain} / users Es ist in Ordnung, wenn Sie darauf zugreifen und der JSON des registrierten Benutzers zurückgegeben wird.

Automatische Bereitstellung mit CircleCI

Nachdem Sie im letzten, CircleCI, auf Master geklickt haben, aktualisieren wir die Aufgabendefinition automatisch, aktualisieren den ECS-Dienst und ermöglichen das Aktualisieren der Aufgabe.

Gesamtdurchfluss

Schieben Sie von lokal zu Github
→ Starten Sie CircleCI über Github
→ Führen Sie Docker Build auf CircleCI aus
→ Schieben Sie das Bild auf CircleCI auf ECR
→ ECS-Dienst aktualisieren ...

Es wird sein.

Bohnenwissen

Der Unterschied zum lokalen Gebäude besteht in der Anwesenheit oder Abwesenheit von Umgebungsvariablen.

Der auf CircleCI ** ausgeführte Build verweist auf den Quellcode im Git-Repository ** und wird auch ** in einer virtuellen Maschine ** ausgeführt. Wenn die zum Ausführen von Rails erforderlichen Umgebungsvariablen nicht im Git-Repository vorhanden sind, können die Umgebungsvariablen nicht referenziert werden und schlagen fehl. Mit CircleCI können Sie jedoch Umgebungsvariablen auf der virtuellen Maschine festlegen.

Umgebungsvariablen einstellen

Project Settings>Environment Variables

AWS_ACCESS_KEY_ID //AWS-Zugriffsschlüssel
AWS_SECRET_ACCESS_KEY //Geheimer AWS-Zugriffsschlüssel
AWS_ACCOUNT_ID //Siehe URL unten
AWS_ECR_ACCOUNT_URL //Beispiel für eine ECR-URL:{Konto-ID}.dkr.ecr.{Region}.amazonaws.com
AWS_REGION //Region

RAILS_MASTER_KEY // ./back/config/Meister unten.Wert des Schlüssels
AWS_RESOURCE_NAME_PREFIX //Präfix des von mir erstellten Dienstes (diesmal Qiita)-sample）
CLUSTER_NAME //Der Name des zuvor erstellten Clusters
REPO_NAME_FRONT //ECR-Repository-Name der Front
REPO_NAME_BACK //ECR-Repository-Name von back
FAMILY_NAME_FRONT //Der Name der Aufgabendefinition von front
FAMILY_NAME_BACK //Der Name der Aufgabendefinition von back
SERVICE_NAME_FRONT //Der Name des zuvor erstellten Front-ECS-Dienstes
SERVICE_NAME_BACK //Der Name des zuvor erstellten Front-ECS-Dienstes

AWS-Konto-ID bestätigen

config.yml Einstellungen

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

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

#Job zum Ausführen
jobs:
  #Job zu bauen
  build:
    machine:
      image:                              circleci/classic:edge
    steps:
      - checkout
      - run:
          name:                           docker-compose build
          command:                        docker-compose build
  #Job zu testen
  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 zur Steuerung der Bestellung
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="Bitte beachten Sie, dass dies der in der Aufgabendefinition festgelegte Containername ist.
            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="Bitte beachten Sie, dass dies der in der Aufgabendefinition festgelegte Containername ist.
            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

Erstellen Sie eine Produktions-Docker-Datei

dockerfile:./back.Dockerfile.pro

#Angeben eines Bildes
FROM ruby:2.6.3-alpine3.10

#Laden Sie die erforderlichen Pakete herunter
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

#Wechseln Sie in das Arbeitsverzeichnis
WORKDIR ${HOME}

#Kopieren Sie die erforderlichen Dateien vom Host (Dateien auf Ihrem Computer) nach 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*

#Kopieren Sie die erforderlichen Dateien vom Host (Dateien auf Ihrem Computer) nach Docker
ADD . ${HOME}

#Öffnen Sie den Port 3000
EXPOSE 3000

#Befehl ausführen
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.Nützlich, wenn Sie den Rails-Server nicht mit pid löschen können
    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: #hinzufügen
      RAILS_MASTER_KEY: ${RAILS_MASTER_KEY}
    volumes:
      - ./back:/app:cached
    depends_on:
      - db
    #Host-Computer-Port: Port in Docker
    ports:
      - 3000:3000

  front:
    build:              front/
    command:            yarn run dev
    volumes:
      - ./front:/app:cached
    ports:
      #Host-Computer-Port: Port in Docker
      - 8080:3000
    depends_on:
      - back
volumes:
  public-data:
  tmp-data:
  log-data:
  db-data:

Bereitstellen

Danke für deine harte Arbeit! Wie unten gezeigt, wird die Bereitstellung erfolgreich abgeschlossen, wenn alle Schritte erfolgreich sind.

Referenz

Diejenigen, die mehr über VPC, AWS-Netzwerk usw. erfahren möchten. AWS-Kurs mit Video-VPC gelernt [Abschnitt 1] Region, Verfügbarkeitszone, Subzone

Diejenigen, die mehr über das Docker-Netzwerk und ECS erfahren möchten Docker-Kurs, um von nun an aufzuholen! Zielen Sie mit AWS ECS und Fargate auf den Container Master! ~ Serie 1 ~

Es ist eine sehr günstige Zeit, um aus Videos zu lernen ... Ich habe es ungefähr 30 Mal wiederholt.

Schließlich

Danke für deine harte Arbeit. Jetzt können Sie Nuxt und Rails mit ECS / ECR / CircleCI für die Produktion bereitstellen. Dies ist nur ein Beispiel, und ich denke, es gibt andere gute Konfigurationen. Sobald Sie es jedoch erstellt und debuggt haben, wissen Sie, wie es geht. (Ich habe noch mehr Möglicherweise enthält dieser Artikel Tippfehler oder Fehler. In einem solchen Fall würde ich es begrüßen, wenn Sie Masakari sanft werfen könnten.

Das nächste Mal wünschte ich, ich könnte auf Terraform schreiben.