Déployer une application Spring Boot sur Google App Engine

1. Vue d'ensemble

Dans ce didacticiel, nous montrerons comment déployer une application à partir de notre Bootstrap a Simple Application à l'aide du didacticiel Spring Boot sur App Engine sur Google Cloud Platform.

Dans ce cadre, nous:

  • Configurer la console et le SDK Google Cloud Platform
  • Utilisez Cloud SQL pour créer une instance MySQL
  • Configurer l'application pour Spring Cloud GCP
  • Déployez l'application sur App Engine et testez-la

2. Configuration de Google Cloud Platform

Nous pouvons utiliser la console GCP pour préparer notre environnement local pour GCP. Nous pouvons trouver le processus d'installation sur le site officiel.

Créons un projet sur GCP à l'aide de la console GCP:

gcloud init

Ensuite, configurons le nom du projet:

gcloud config set project baeldung-spring-boot-bootstrap

Ensuite, nous installerons la prise en charge d'App Engine et créerons une instance App Engine:

gcloud components install app-engine-java gcloud app create

Notre application devra se connecter à une base de données MySQL dans l'environnement Cloud SQL. Comme Cloud SQL ne propose pas de version gratuite, nous devrons activer la facturation sur le compte GCP.

Nous pouvons vérifier facilement les niveaux disponibles:

gcloud sql tiers list 

Avant de continuer, nous devons utiliser le site Web GCP pour activer l'API d'administration Cloud SQL.

Nous pouvons désormais créer une instance et une base de données MySQL dans Cloud SQL à l'aide de Cloud Console ou de l'interface de ligne de commande du SDK. Au cours de ce processus, nous choisirons la région et fournirons un nom d'instance et un nom de base de données. Il est important que l'application et l'instance de base de données se trouvent dans la même région.

Puisque nous allons déployer l'application sur europe-west2 , faisons de même pour l'instance:

# create instance gcloud sql instances create \ baeldung-spring-boot-bootstrap-db \ --tier=db-f1-micro \ --region=europe-west2 # create database gcloud sql databases create \ baeldung_bootstrap_db \ --instance=baeldung-spring-boot-bootstrap-db

3. Dépendances de Spring Cloud GCP

Notre application aura besoin des dépendances du projet Spring Cloud GCP pour les API cloud natives. Pour cela, utilisons un profil Maven nommé cloud-gcp :

 cloud-gcp   org.springframework.cloud spring-cloud-gcp-starter 1.0.0.RELEASE   org.springframework.cloud spring-cloud-gcp-starter-sql-mysql 1.0.0.RELEASE  

Ensuite, nous ajoutons le plugin App Engine Maven:

    com.google.cloud.tools appengine-maven-plugin 1.3.2    

4. Configuration de l'application

Maintenant, définissons la configuration qui permet à l'application d'utiliser les ressources cloud natives comme la base de données.

Spring Cloud GCP utilise spring-cloud-bootstrap.properties pour déterminer le nom de l'application:

spring.cloud.appId=baeldung-spring-boot-bootstrap

Nous utiliserons un profil Spring nommé gcp pour ce déploiement et nous devrons configurer la connexion à la base de données. Par conséquent, nous créons src / main / resources / application-gcp.properties :

spring.cloud.gcp.sql.instance-connection-name=\ baeldung-spring-boot-bootstrap:europe-west2:baeldung-spring-boot-bootstrap-db spring.cloud.gcp.sql.database-name=baeldung_bootstrap_db

5. Déploiement

Google App Engine fournit deux environnements Java:

  • l' environnement Standard fournit Jetty et JDK8 et l' environnement Flexible fournit uniquement JDK8 et
  • l'environnement flexible est la meilleure option pour les applications Spring Boot.

Nous avons besoin que les profils gcp et mysql Spring soient actifs, nous fournissons donc la variable d'environnement SPRING_PROFILES_ACTIVE à l'application en l'ajoutant à la configuration de déploiement dans src / main / appengine / app.yaml :

runtime: java env: flex runtime_config: jdk: openjdk8 env_variables: SPRING_PROFILES_ACTIVE: "gcp,mysql" handlers: - url: /.* script: this field is required, but ignored manual_scaling: instances: 1

Maintenant, construisons et déployons l'application à l'aide du plugin appengine maven :

mvn clean package appengine:deploy -P cloud-gcp

Après le déploiement, nous pouvons afficher ou terminer les fichiers journaux:

# view gcloud app logs read # tail gcloud app logs tail

Maintenant, vérifions que notre application fonctionne en ajoutant un livre :

http POST //baeldung-spring-boot-bootstrap.appspot.com/api/books \ author="Iain M. Banks" 

Attente de la sortie suivante:

HTTP/1.1 201 { "author": "Iain M. Banks", "id": 1, "title": "The Player of Games" }

6. Mise à l'échelle de l'application

La mise à l'échelle par défaut dans App Engine est automatique.

Il peut être préférable de commencer par une mise à l'échelle manuelle jusqu'à ce que nous comprenions le comportement d'exécution, les budgets et les coûts associés. Nous pouvons affecter des ressources à l'application et configurer la mise à l'échelle automatique dans app.yaml :

# Application Resources resources: cpu: 2 memory_gb: 2 disk_size_gb: 10 volumes: - name: ramdisk1 volume_type: tmpfs size_gb: 0.5 # Automatic Scaling automatic_scaling: min_num_instances: 1 max_num_instances: 4 cool_down_period_sec: 180 cpu_utilization: target_utilization: 0.6

7. Conclusion

Dans ce tutoriel, nous:

  • Configuration de Google Cloud Platform et d'App Engine
  • Création d'une instance MySQL avec Cloud SQL
  • Configuration de Spring Cloud GCP pour l'utilisation de MySQL
  • Déploiement de notre application Spring Boot configurée et
  • Testé et mis à l'échelle l'application

Nous pouvons toujours consulter la vaste documentation App Engine de Google pour plus de détails.

Le code source complet de nos exemples ici est, comme toujours, sur GitHub.