[JAVA] Jusqu'à ce que vous déployez un projet SpringBoot dans Gradle avec App Engine Flexible

L'environnement flexible de Google App Engine est sorti depuis longtemps, mais c'est un mémo car je n'ai pas trouvé d'exemple qui déploie et exécute le projet spring-boot ** avec ** gradle. La documentation officielle est centrée sur ** maven **

Source pour le moment

Mettez-le sur github appenginetest

environnement

OS Windows10 pro Java Java SE 1.8.0_121 Gradle 3.4.1 Eclipse Pleiades All in One 4.6.3.v20170323

Préparation

La création d'un compte pour Google Cloud Platform est omise ici.

Installez le SDK Google Cloud

Document officiel est facile à comprendre, donc omis

Installation du SDK App Engine pour Java

Une fois l'initialisation du SDK terminée, lancez la commande suivante pour installer le SDK pour Java

gcloud components install app-engine-java

Créer un projet de test avec GCP

Créer un nouveau projet sur Google Cloud Platform Cette fois, je vais le faire avec le nom ** spring boot test ** Notez l'ID du projet car vous l'utiliserez plus tard.

Préparation du projet Spring-Boot

Je vais le faire en utilisant Eclipse

Création de projet

Sélectionnez le projet Gradle dans Fichier-> Nouveau-> Autre Le nom du projet est ** appenginetest **

Sur l'écran suivant, spécifiez le Gradle que vous avez installé Était-il possible de conserver la valeur par défaut en fonction des paramètres Eclipse?

Vérifiez la configuration sur l'écran suivant, et s'il n'y a pas d'avertissement, c'est terminé Je reçois un avertissement si les paramètres de gradle ne sont pas corrects

Une fois terminé, Library.java et LibraryTest.java sont créés sous src, mais ils ne seront pas utilisés, supprimez-les.

paramètres de gradle

Ouvrez build.gradle et définissez divers paramètres

Plug-in App Engine

Reportez-vous à cette zone Officiellement, j'utilise un plug-in appelé ** gretty **, mais cette fois je vais utiliser Spring-Boot, donc je vais le supprimer.

Eh bien, je ne savais tout simplement pas comment l'utiliser ...

exemple build.gradle

Et voici le réglage de spring-boot

build.gradle

buildscript {
	repositories {
		jcenter()
		mavenCentral()
	}
	dependencies {
		classpath 'com.google.cloud.tools:appengine-gradle-plugin:1.1.1'
		classpath 'org.springframework.boot:spring-boot-gradle-plugin:1.5.+'
	}
}

apply plugin: 'java'
apply plugin: 'org.springframework.boot'
apply plugin: 'com.google.cloud.tools.appengine'
apply plugin: 'eclipse'

def defaultEncoding = 'UTF-8'
[compileJava, compileTestJava]*.options*.encoding = defaultEncoding

def jdkVersion = 1.8
sourceCompatibility = jdkVersion
targetCompatibility = jdkVersion

jar {
	baseName = 'appenginetest'
	version = '1.0-SNAPSHOT'
}

repositories {
	maven {
		url 'https://maven-central.storage.googleapis.com'
	}
    jcenter()
	mavenCentral()
}

dependencies {
	compile 'javax.servlet:javax.servlet-api:3.1.0'
	compile 'com.google.appengine:appengine:+'

	compile('org.springframework.boot:spring-boot-starter-web:1.5.+'){
		exclude module: 'spring-boot-starter-tomcat'
	}

	compile group: 'org.springframework.boot', name: 'spring-boot-starter-jetty', version: '1.5.+'
}

Pour le moment, je viens de le déployer et d'afficher quelque chose, donc c'est comme ça

La source

Ensuite, le fichier java utilisé par Spring-Boot

Application.java

package appenginetest;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class Application {

	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}

	@RequestMapping(value = "/")
	String hello() {
		return "Hello World!";
	}
}

Je ne peux voir que "Hello World!" Parce que je veux juste le voir se déployer et fonctionner

Paramètres pour AppEngine

Ensuite, écrivez le fichier de configuration pour AppEngine L'emplacement sera * src / main / appengine *

app.yaml

runtime: custom
env: flex

runtime_config:
   jdk: openjdk8

automatic_scaling:
  min_num_instances: 1
  max_num_instances: 1

Si vous utilisez java8 + jetty standard, spécifiez * runtime * comme * java *, mais cette fois, il s'agit d'un environnement personnalisé de * Spring-Boot + jetty *, définissez-le donc sur * custom *.

• automatic_scaling * est le nombre d'instances à démarrer, et s'il n'est pas spécifié, au moins 2 seront démarrées, alors spécifiez 1

Il y en a beaucoup d'autres, mais voir Officiel.

Paramètres Dockerfile

Ecrire les paramètres de Docker s'exécutant sur AppEngine L'emplacement sera * src / main / Docker *

Dockerfile

FROM gcr.io/google_appengine/openjdk8
VOLUME /tmp
ADD appenginetest-1.0-SNAPSHOT.jar app.jar
CMD [ "java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

• appenginetest-1.0-SNAPSHOT.jar * spécifie le fichier jar créé lors de la construction du projet

Essayez de construire

Accédez à la racine du projet créé avec l'invite de commande et exécutez la commande suivante

gradle appengineStage

Si les paramètres sont corrects, quittez avec * BUILD SUCCESSFUL *

Déployer sur App Engine

Paramètres du projet

Définir les paramètres de ce projet Créez un paramètre avec la commande suivante

gcloud config configurations create [NAME]

Donnez à [NAME] un nom descriptif

Après le réglage, activez le réglage

gcloud config configurations activate [NAME]

Activez les paramètres et associez le projet créé à Google Cloud Platform Veuillez donc noter ici, veuillez utiliser le nom du projet ** ID du projet ** La partie rouge ici, si vous spécifiez le nom du projet de manière incorrecte, vous n'obtiendrez pas d'erreur, mais cela échouera dans le déploiement final

gcloud config set project [PROJECT]

Définition de la zone par défaut du projet

gcloud config set compute/zone us-east1-b

La commande suivante pour afficher les paramètres

gcloud config configurations describe [NAME]

Vous pouvez vérifier quels sont les paramètres valides avec la commande suivante

gcloud config list

Connectez-vous une fois que vous avez les paramètres valides

gcloud auth login

Un navigateur s'ouvrira et une liste de comptes pour se connecter apparaîtra, alors sélectionnez un compte que vous pouvez vous connecter avec Google Cloud Platform. Sur l'écran suivant, le SDK Google Cloud vous demandera l'autorisation, alors autorisez-la.

Je ne suis pas sûr de la procédure ici Je lance peut-être des commandes supplémentaires ...

La documentation officielle est ici

Déployer sur App Engine

Si vous pouvez confirmer les paramètres valides, il est enfin déployé Exécutez la commande suivante à partir de la racine du projet

gradle appengineDeploy

Attendez un moment après avoir exécuté la commande Même ce petit exemple de projet prend environ 5 minutes

Regarde

Lorsque la commande de déploiement revient, il y a un lien dans le coin supérieur droit du tableau de bord App Engine, alors vérifions-le à partir de là. Si "Hello World!" S'affiche, cela signifie que l'opération réussit.

alors

C'est le minimum Ensuite, c'est DB, mais je vais le donner séparément