Java >> Java Tutorial >  >> Tag >> Spring

So stellen Sie die Spring Boot-Anwendung auf AWS ECS bereit

Spring

In diesem Beitrag werde ich zeigen, wie wir eine Spring-Boot-Anwendung auf AWS ECS (Elastic Container Service) bereitstellen können. ECS ist einer der Amazon-Webdienste, der hauptsächlich zum Ausführen der Anwendungen verwendet wird. Es ist eine Alternative, EC2-Instances direkt zu verwenden.

Was ist ECS?

ECS ist ein Container-Orchestrierungsdienst. Mit ECS können Sie Ihren Container ausführen. Sie können ECS-Cluster auch einfach mit AWS Farget erstellen. Farget macht die Bereitstellung und Verwaltung eines Servers überflüssig. Der Vorteil der Verwendung von ECS besteht darin, dass Sie sich nicht entscheiden müssen, welche Server-EC2-Instanz Sie verwenden möchten, der Dienst erledigt das für Sie. Es verbessert auch die Sicherheit durch Anwendungsisolierung.

Als Teil dieser Demo zeige ich Schritt für Schritt, wie Sie Ihre Spring-Boot-Anwendung auf dem ECS-Cluster mit AWS Fargate bereitstellen können.

Spring Boot-Anwendung

Ich werde Ihnen nicht zeigen, wie Sie eine Spring Boot-Anwendung erstellen, aber Sie können meine anderen Beiträge dazu besuchen. In dieser Anwendung haben wir einen Controller, der eine Aufgabenliste anzeigt. Wir werden auch eine formularbasierte Authentifizierung mit der MySQL-Datenbank haben. Der config Methode in der Sicherheitskonfiguration sieht wie folgt aus:


    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception
    {
        httpSecurity
                .authorizeRequests()
                .antMatchers("/js/**","/css/**","/img/**").permitAll()
                .antMatchers("/signup","/forgotpassword")
                .permitAll()
                .anyRequest().authenticated()
                .and()
                .formLogin()
                .loginPage("/login")
                .permitAll()
                .and()
                .logout()
                .logoutUrl("/logout")
                .logoutSuccessHandler(logoutSuccessHandler)
                .deleteCookies("JSESSIONID")
                .permitAll()
                .and()
                .csrf();

    }

Wie Sie oben sehen, erlauben wir also jedem, auf signup zuzugreifen und forgotpassword Seiten. Ebenso kann jeder auf die Anmeldeseite zugreifen. Wir verwenden unser benutzerdefiniertes Anmeldeformular auf der Anmeldeseite.

Wenn sich der Benutzer erfolgreich anmeldet, sieht der Benutzer eine statische TO-DO-Listenseite mit der TO-DO-Liste.

Als Teil dieser Demo werden wir auch eine MySQL-Datenbank in AWS RDS erstellen. Unsere im AWS Fargate ECS-Cluster ausgeführte Anwendung greift auf diese MySQL-Datenbank zum Speichern von Benutzern und zur Benutzerauthentifizierung zu.

Erstellen eines Docker-Containers für die Spring Boot-Anwendung

Wir erstellen eine Docker-Datei.

FROM openjdk:8-jdk-alpine
COPY ./build/libs/todolist-0.0.1-SNAPSHOT.war todolist-0.0.1-SNAPSHOT.war
ENTRYPOINT ["java", "-jar","todolist-0.0.1-SNAPSHOT.war"]

Grundsätzlich ziehen wir das Java 8-Image und kopieren die WAR-Datei aus unserem Projekt in die Docker-Instanz. Wir definieren auch den Einstiegspunkt.

Befehl zum Erstellen eines Docker-Images

docker build -t todolist .

Wenn Sie Ihre Anwendung lokal über Docker ausführen möchten, können Sie den folgenden Befehl verwenden:

docker run -p 8743:8743 todolist

Um unsere Anwendung auf ECS bereitzustellen, müssen wir dieses Docker-Image in das Elastic Container Repository (ECR) verschieben.

Normalerweise ist das Erstellen eines Docker-Images und das Pushen an ECR alles Teil von CI/CD. Ich werde CI/CD in diesem Beitrag nicht behandeln.

Um dieses Docker-Image an ECR zu übertragen,

  1. Sie benötigen aws-cli Tools, die auf Ihrem Computer installiert sind.
  2. Erstellen Sie ein Repository in ECR

Führen Sie nun in der Befehlszeile diesen Befehl aus, um den Docker-Client beim ECR-Repository zu authentifizieren

aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin XXXXXXX.dkr.ecr.us-east-1.amazonaws.com

Sobald wir authentifiziert sind, können wir Docker-Images markieren und in das ECR-Repository übertragen.

  1. Taggen Sie das Docker-Image – docker tag IMAGEID XXXXXX.dkr.ecr.us-east-1.amazonaws.com/todolist
  2. Push das Docker-Image – docker push XXXXX.dkr.ecr.us-east-1.amazonaws.com/todolist

Jetzt ist unser Docker-Image in ECR.

Docker-Image in ECS bereitstellen

Bevor wir unser Docker-Image in ECS bereitstellen können, müssen wir drei Schritte ausführen.

  1. Erstellen Sie eine Datenbankinstanz von MySQL in AWS RDS. Die Konfiguration zum Erstellen dieser Instanz sieht wie folgt aus:
  2. Sobald Sie die Datenbank erstellt haben, stehen Ihnen der Datenbankinstanzserver und der Port zur Verfügung, die Sie verwenden können, um eine Verbindung zum Datenbankserver entweder über die Benutzeroberfläche der Datenbankverwaltung oder über die Befehlszeile herzustellen. Erstellen Sie eine Datenbank simplifyingspringsecurity und Datenbanktabelle users .
  3. Lassen Sie uns nun zum ECS-Service wechseln und eine Aufgabendefinition für AWS Fargate erstellen. Es wird wie folgt aussehen: Denken Sie auch daran, vorher eine IAM-Rolle zu erstellen, die eine Berechtigungsrichtlinie „AmazonECSTaskExecutionRolePolicy“ haben sollte. In derselben Aufgabendefinition müssen wir unseren Container und die Eigenschaften für diesen Container hinzufügen. Sie werden wie folgt aussehen:Wir haben zwei Ports 8743 und 80 von unserem Host dem Container zugeordnet. Fügen Sie im selben Container auch Umgebungseigenschaften hinzu, wenn Sie Eigenschaften für Ihre Datenquelle überschreiben möchten. Zu diesen Eigenschaften gehört spring.datasource.url , spring.datasource.username , spring.datasource.password , spring.datasource.driver-class-name , und spring.jpa.properties.hibernate.dialect . Das sollte unsere Konfiguration für die Aufgabe abdecken.
  4. Letztendlich erstellen wir einen ECS-Cluster, den wir zum Ausführen unserer Aufgabe verwenden. Wie Sie sehen, haben wir uns für einen auf AWS Fargate basierenden Cluster entschieden. Geben Sie im nächsten Schritt einen Namen für den Cluster ein und klicken Sie auf „Erstellen“. Dadurch sollte ein Cluster erstellt werden.
  5. Sobald der Cluster konfiguriert ist und ausgeführt wird, können wir auf die Registerkarte „Aufgaben“ gehen und auf „Neue Aufgabe ausführen“ klicken. Hier werden wir einige weitere Konfigurationen bereitstellen, die es uns ermöglichen, unsere Aufgabe so auszuführen, dass wir auf die Anwendung zugreifen können, sobald die Aufgabe gestartet wird. Wir haben hier Sicherheitsgruppen definiert, aber es bietet auch die Option, während der Ausführung eine neue Sicherheitsgruppe zu erstellen. In dieser Sicherheitsgruppe sollten Sie auswählen, welche Art von Protokoll und Ports Sie für den Zugriff zulassen möchten. In diesem Fall wollen wir unseren Port 8743 für Internet und TCP. Klicken Sie nun auf „Task ausführen“ und das sollte die Aufgabe starten. Sobald die Aufgabe gestartet ist, können wir die Protokolle von Cloud Watch wie folgt sehen:Auf dieser Grundlage, wenn Sie sich die Protokolle ansehen, läuft unsere Anwendung jetzt erfolgreich auf Port 8743. Jetzt können wir Greifen Sie über die öffentliche IP-Adresse, die die Fargate-Aufgabe bereitgestellt hat, auf die Anwendung zu. Los geht's, wir haben unsere Anwendung zum Laufen gebracht.

Lernen

ECS kann mit der Anzahl der Konfigurationen, die ein Benutzer beim Bereitstellen einer Anwendung vornehmen kann, kompliziert sein. Um es einfach zu halten, denken Sie einfach so:AWS Cloud -> VPC -> Subnet -> ECS -> Fargate -> Task.

Schlussfolgerung

In diesem Beitrag habe ich gezeigt, wie eine Spring Boot-Anwendung auf AWS ECS bereitgestellt wird. So einfach es scheint, das Problem liegt in der Kombination von Konfigurationen, die Sie in AWS ECS vornehmen können. Sobald Sie verstehen, wie die Cloud mit privaten Netzwerken umgeht, wird es einfacher.


Java-Tag