[Code Pipeline x Elastic Beanstalk] CI / CD-Java-Anwendung für Elastic Beanstalk mit Code Pipeline Part 1

Hands-on zur CI / CD-Java-Anwendung (ruft den Wert aus der Datenbank ab und gibt das Ergebnis im JSON-Format zurück) an Elastic Beanstalk mit CodePipeline.

Weil es lang ist

• [Code Pipeline x Elastic Beanstalk] CI / CD-Java-Anwendung für Elastic Beanstalk mit Code Pipeline Teil 1 (dieser Artikel)
  → 1. Java-Anwendung (Spring Boot) erstellen, 2. Git-Repository erstellen
• [Code Pipeline x Elastic Beanstalk] CI / CD-Java-Anwendung für Elastic Beanstalk mit Code Pipeline Teil 2
  → 3. Elastic Beanstalk-Umgebung erstellen, 4. Datenbankeinstellungen
• [Code-Pipeline x Elastic Beanstalk] CI / CD-Java-Anwendung für Elastic Beanstalk mit Code-Pipeline Teil 3
  → 5. Erstellen einer Pipeline, 6. Aufräumen

Der Inhalt ist in 3 Artikel unterteilt. Die Gesamtarbeitszeit wird ohne vorherige Vorbereitung mit ca. 3 Stunden angenommen. Etwa 1 Stunde für jeden Artikel ist eine Anleitung.

Umgebung

• OS：Windows10
• IDE：Eclipse 2020-03
• JDK：Amazon Correto 8
• Rahmenwerk: Spring Boot
• AWS
  • CodePipeline
    • CodeCommit
    • CodeBuild
    • CodeDeploy
  • Elastic Beantalk
• Java SE (Java 8 Version 2.10.8)
  → Sie können dasselbe für verschiedene Plattformzweige tun (z. B. Corretto 11). --RDS: MySQL Community Edition (Version 8.0.17)

Bilddiagramm

Dies ist ein grobes Bild davon, was Sie mit diesem Verfahren tun können. Wenn Sie den lokal bearbeiteten Code auf Commit → CodeCommit verschieben, erstellt CodePipeline einen CI / CD-Mechanismus, der automatisch erstellt und in Elastic Beanstalk bereitgestellt wird, der Anwendungsausführungsumgebung.

Vorbereitungen

① Wenn Eclipse nicht installiert ist, Plejaden alles in einer Eclipse herunterladen (Release 2020-06) | MergeDoc-Projekt Bitte laden Sie die neueste Version herunter (Stand: 3. August 2020). Wenn STS und Lombok bereits konfiguriert sind, können Sie sofort mit der Entwicklung mit Spring Boot beginnen.

(2) JDK geht von Amazon Correto 8 aus. Amazon Corretto 8 | aws herunterladen Bitte laden Sie die Einstellungen für Eclipse herunter → installieren Sie sie und vervollständigen Sie sie.

③ Damit CodeCommit verwendet werden kann Verwendung von AWS CodeCommit. Von wo aus machen Sie einen Zugangsschlüssel. | Qiita Bitte treffen Sie die Vorbereitungen im Voraus unter Bezugnahme auf.

Verfahren

1. Erstellen einer Java-Anwendung (Spring Boot)

Erstellen Sie zunächst eine Java-Anwendung (Spring Boot) in Eclipse. Es ist sehr einfach, detaillierte Geschäftsinformationen basierend auf der Geschäfts-ID abzurufen. Die Struktur des Pakets ist wie folgt.

sample-eb-java
     |
    src/main/java
     |----jp.co.sample_eb_java
     |               |---- app
     |               |     |---- controller
     |               |     |---- response
     |               |
     |               |---- domain
     |               |      |---- service
     |               |      |---- repository
     |               |      |---- model
     |               |  
     |               |---- exception
     |               
     |
    src/main/resources
     |----application.yml
     |
    Buildfile
    Procfile
    build.gradle
    .ebextensions

・ ・ ・ Unten weggelassen

[1] Erstellen eines Projekts

(1) Klicken Sie nach dem Öffnen von Eclipse auf "Datei" (①)> "Neu" (②)> "Projekt" (③).

(2) Wenn der Assistent gestartet wird, wählen Sie "Spring Starter Project" (①) und klicken Sie auf "Next" (②).

(3) Stellen Sie wie in der Aufnahme unten (1) gezeigt ein und klicken Sie auf "Weiter" (2).

(4) Überprüfen Sie Lombok, MySQL-Treiber, Spring Data JPA, Spring Web (wenn Sie kein Kandidat sind, suchen Sie bitte im Suchfeld) und klicken Sie auf "Weiter" (②).

[2] Einstellungsdatei ändern / erstellen

Als nächstes ändern und erstellen Sie die Einstellungsdatei.

(1) Benennen Sie application.properties in application.yml um und schreiben Sie wie folgt.

• Sie können application.properties so lassen, wie es ist, aber wir haben dies basierend auf dem aktuellen Trend (?) Gemacht.

application.yml

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://${DB_HOST:Hostname}:${DB_PORT:Port-Nummer}/${DB_NAME:Name der Datenbank}?serverTimezone=JST
    username: ${DB_USERNAME:Nutzername}
    password: ${DB_PASSWORD:Passwort}
  jpa:
    database: MYSQL
    hibernate.ddl-auto: none
server:
  port: ${SERVER_PORT:Server-Portnummer}

Ich werde den japanischen Teil später ändern, also lass ihn wie er ist.

(2) Erstellen Sie eine Build-Datei im Stammverzeichnis und beschreiben Sie diese wie folgt.

Buildfile

build: ./gradlew assemble

(3) Erstellen Sie eine Prozessdatei im Stammverzeichnis und beschreiben Sie diese wie folgt.

Procfile

web: java -jar build/libs/sample-eb-java.jar

(4) Zu build.gradle hinzufügen. Suchen Sie das Teil vor dem Hinzufügen und fügen Sie "bootJar.archiveName =" sample-eb-java.jar "" hinzu.

build.Gradle (vor Zugabe)

configurations {
	compileOnly {
		extendsFrom annotationProcessor
	}
}

build.Gradle (nach Zugabe)

configurations {
	compileOnly {
		extendsFrom annotationProcessor
	}
	bootJar.archiveName = "sample-eb-java.jar"
}

[3] Quellcode erstellen

Als nächstes wird der Quellcode erstellt. Die Paketstruktur ist wie am Anfang dieses Kapitels gezeigt (1. Erstellen einer Java-Anwendung (Spring Boot)), aber ich denke, es wäre mühsam, nach oben zurückzukehren, sodass ich eine Erfassung veröffentlichen werde.

(1) Erstens die Entitätsklasse. Es wird später veröffentlicht, entspricht jedoch der in der Datenbank erstellten Tabelle shop_informations.

ShopInformation.java

package jp.co.sample_eb_java.domain.model;

import java.io.Serializable;
import javax.persistence.*;

import lombok.Getter;
import lombok.Setter;


/**
 *Entitätsklasse, die mit der Geschäftsinformationstabelle verknüpft ist
 * 
 * @author CHI-3
 *
 */
@Entity
@Getter
@Setter
@Table(name="shop_informations")
@NamedQuery(name="ShopInformation.findAll", query="SELECT s FROM ShopInformation s")
public class ShopInformation implements Serializable {
	private static final long serialVersionUID = 1L;

	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="shop_id")
	private Integer shopId;

	private String access;

	private String address;

	@Column(name="business_hour")
	private String businessHour;

	@Column(name="regular_holiday")
	private String regularHoliday;

	@Column(name="shop_name")
	private String shopName;

	private String tel;

	@Column(name="zip_code")
	private String zipCode;

	public ShopInformation() {
	}

}

(2) Als nächstes die Repository-Schnittstelle. Die für Tabellenoperationen verwendete Schnittstelle.

ShopInformationRepository.java

package jp.co.sample_eb_java.domain.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import jp.co.sample_eb_java.domain.model.ShopInformation;

/**
 *Repository-Schnittstelle, die Speicherinformationen verarbeitet
 *
 * @author CHI-3
 *
 */
@Repository
public interface ShopInformationRepository extends JpaRepository<ShopInformation, Integer>{

	/**
	 *Abrufen von Geschäftsinformationen, die mit der Geschäfts-ID verknüpft sind
	 *
	 * @param shopId Store ID
	 * @Store-Informationen zurückgeben
	 */
	public ShopInformation findByShopId(Integer shopId);

}

(3) Als nächstes die Serviceklasse. Liefert die Logik.

ShopInformationService.java

package jp.co.sample_eb_java.domain.service;

import java.util.Optional;

import org.springframework.stereotype.Service;

import jp.co.sample_eb_java.domain.model.ShopInformation;
import jp.co.sample_eb_java.domain.repository.ShopInformationRepository;
import lombok.RequiredArgsConstructor;

/**
 *Serviceklasse zum Abrufen von Geschäftsinformationen
 *
 * @author CHI-3
 *
 */
@Service
@RequiredArgsConstructor
public class ShopInformationService {

	private final ShopInformationRepository shopInformationRepository;

	/**
	 *Ladeninformationen abrufen
	 *
	 * @param shopId Store ID
	 * @Store-Informationen zurückgeben
	 * @throws Exception
	 */
	public ShopInformation getShopInformation(Integer shopId) throws Exception{
		//Geschäftsinformationen abrufen: Ausnahme auslösen, wenn der Zielspeicher nicht vorhanden ist
		ShopInformation shopInformation = Optional.ofNullable(shopInformationRepository.findByShopId(shopId)).orElseThrow(Exception::new);
		return shopInformation;
	}

}

(4) Als nächstes die Antwortklasse. Wir werden den zurückzugebenden Wert formen.

ShopInformationResponse.java

package jp.co.sample_eb_java.app.response;

import jp.co.sample_eb_java.domain.model.ShopInformation;
import lombok.Builder;
import lombok.Getter;

/**
 *Antwortklasse für die Erfassung von Geschäftsinformationen
 * @author CHI-3
 *
 */
@Getter
@Builder
public class ShopInformationResponse {
	/**Information speichern*/
	private ShopInformation shopInformation;
}

(5) Als nächstes folgt die Controller-Klasse. Ich verwende @RestController, um den Wert im JSON-Format zurückzugeben.

ShopInformationController.java

package jp.co.sample_eb_java.app.controller;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import jp.co.sample_eb_java.app.response.ShopInformationResponse;
import jp.co.sample_eb_java.domain.model.ShopInformation;
import jp.co.sample_eb_java.domain.service.ShopInformationService;
import lombok.RequiredArgsConstructor;

/**
 *API zum Abrufen von Geschäftsinformationen
 * 
 * @author CHI-3
 *
 */
@RestController
@RequiredArgsConstructor
public class ShopInformationController {

	private final ShopInformationService shopInformationService;

	/**
	 *Ladeninformationen abrufen
	 *
	 * @param shopId Store ID
	 * @Rückgabe Entität Entität (Informationen speichern)
	 * @throws Exception
	 */
	@GetMapping("/shop-information/{shopId}")
	public ResponseEntity<ShopInformationResponse> getShopInformation(@PathVariable("shopId") Integer shopId) throws Exception{
		ShopInformation shopInformation = shopInformationService.getShopInformation(shopId);
		ShopInformationResponse shopInformationResponse = ShopInformationResponse.builder().shopInformation(shopInformation).build();
		return new ResponseEntity<>(shopInformationResponse, HttpStatus.OK);
	}

}

(6) Schließlich ExceptionHandler. Diese Klasse behandelt Fehler. Dieses Mal wird beim Anfordern einer nicht vorhandenen Geschäfts-ID ein 400-Fehler (Bad Request) zurückgegeben.

ExceptionHandler.java

package jp.co.sample_eb_java.exception;


import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;

import lombok.extern.slf4j.Slf4j;

/**
 *Ausnahmehandler
 *
 * @author CHI-3
 *
 */
@ControllerAdvice
@Slf4j
public class ExceptionHandler {

    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @org.springframework.web.bind.annotation.ExceptionHandler({Exception.class})
    public @ResponseBody
    ResponseEntity<Object> handleError(final Exception e) {
        log.info("call ExceptionHandler", e);
        return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
    }
}

[4] Erstellen einer JAR-Datei

(1) Erstellen Sie eine JAR-Datei zum Erstellen der Elastic Beantalk-Umgebung. Wechseln Sie in das Stammverzeichnis Ihres Projekts und führen Sie den Befehl build aus. Wenn das Layout wie folgt ist, ist es wie folgt.

Ausführungsbefehl

> cd C:\pleiades-2020-03\workspace\sample-eb-java
> gradlew build

OK, wenn das Ergebnis "BUILD SUCCESSFUL" ist! </ b>

> git init

bin/*
.lock

> git add .
> git commit -m "first commit"

# Created by https://www.toptal.com/developers/gitignore/api/java,gradle,eclipse
# Edit at https://www.toptal.com/developers/gitignore?templates=java,gradle,eclipse

### Eclipse ###
.metadata
bin/
tmp/
*.tmp
*.bak
*.swp
*~.nib
local.properties
.settings/
.loadpath
.recommenders

# External tool builders
.externalToolBuilders/

# Locally stored "Eclipse launch configurations"
*.launch

# PyDev specific (Python IDE for Eclipse)
*.pydevproject

# CDT-specific (C/C++ Development Tooling)
.cproject

# CDT- autotools
.autotools

# Java annotation processor (APT)
.factorypath

# PDT-specific (PHP Development Tools)
.buildpath

# sbteclipse plugin
.target

# Tern plugin
.tern-project

# TeXlipse plugin
.texlipse

# STS (Spring Tool Suite)
.springBeans

# Code Recommenders
.recommenders/

# Annotation Processing
.apt_generated/
.apt_generated_test/

# Scala IDE specific (Scala & Java development for Eclipse)
.cache-main
.scala_dependencies
.worksheet

# Uncomment this line if you wish to ignore the project description file.
# Typically, this file would be tracked if it contains build/dependency configurations:
#.project

### Eclipse Patch ###
# Spring Boot Tooling
.sts4-cache/

### Java ###
# Compiled class file
*.class

# Log file
*.log

# BlueJ files
*.ctxt

# Mobile Tools for Java (J2ME)
.mtj.tmp/

# Package Files #
*.jar
*.war
*.nar
*.ear
*.zip
*.tar.gz
*.rar

# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
hs_err_pid*

### Gradle ###
.gradle
build/

# Ignore Gradle GUI config
gradle-app.setting

# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
!gradle-wrapper.jar

# Cache of project
.gradletasknamecache

# # Work around https://youtrack.jetbrains.com/issue/IDEA-116898
# gradle/wrapper/gradle-wrapper.properties

### Gradle Patch ###
**/build/

# End of https://www.toptal.com/developers/gitignore/api/java,gradle,eclipse

> git add .gitignore
> git commit -m "fix .gitignore"

> git ls-files -s gradlew
100644 fbd7c515832dab7b01092e80db76e5e03fe32d29 0       gradlew

> git update-index --add --chmod=+x gradlew

> git ls-files -s gradlew
100755 fbd7c515832dab7b01092e80db76e5e03fe32d29 0       gradlew

> git add gradlew
> git commit -m "fix permission of gradlew"

> git remote add origin (1)URI in "HTTPS-Klon" kopiert

> git push -u origin master