TOC

Déployer une application de démarrage de printemps sur Google App Engine

1. Vue d’ensemble

Dans ce tutoriel, nous montrerons comment déployer une application à partir de notre tutoriel Bootstrap une application simple à l’aide de Spring Boot à App Engine sur Google Cloud Platform.

Dans le cadre de cela, nous allons:

  • Configurer la console Google Cloud Platform et le SDK

  • Utiliser 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 la plateforme Google Cloud

Nous pouvons utiliser la console GCP pour préparer notre environnement local pour GCP.

Vous trouverez le installation process sur le site officiel.

Créons un projet sur GCP en utilisant la console GCP 

gcloud init

Ensuite, configurons le nom du projet: 

gcloud config set project baeldung-spring-boot-bootstrap

Nous installerons ensuite le support 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. Cloud SQL ne fournissant pas de niveau gratuit, nous devons activer billing 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 Cloud .

Nous pouvons maintenant créer une instance et une base de données MySQL dans Cloud SQL à l’aide de la console Cloud ou de la CLI 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.

Comme nous allons déployer l’application sur europe-west2 , procédons 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 Spring Cloud GCP

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

<profile>
  <id>cloud-gcp</id>
  <dependencies>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-gcp-starter</artifactId>
      <version>1.0.0.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-gcp-starter-sql-mysql</artifactId>
      <version>1.0.0.RELEASE</version>
    </dependency>

Ensuite, nous ajoutons le plugin App Engine Maven: 

    <build>
      <plugins>
        <plugin>
          <groupId>com.google.cloud.tools</groupId>
          <artifactId>appengine-maven-plugin</artifactId>
          <version>1.3.2</version>
        </plugin>
      </plugins>
    </build>
</profile>

4. Configuration de l’application

Maintenant, définissons la configuration qui permet à l’application d’utiliser les ressources natives en nuage telles que 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 allons utiliser un profil de printemps nommé gcp pour ce déploiement et nous devons 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 le Flexible

environnement fournit seulement JDK8 et ** l’environnement flexible est la meilleure option pour Spring Boot

applications.

Les profils gcp et mysql Spring étant actifs, nous fournissons 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 archiver 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 https://baeldung-spring-boot-bootstrap.appspot.com/api/books \
        title="The Player of Games" author="Iain M. Banks"

S’attendant à 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 de l’exécution, ainsi que 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 du moteur d’application

  • Création d’une instance MySQL avec Cloud SQL

  • Configuré Spring Cloud GCP pour utiliser MySQL

  • Déployé notre application Spring Boot configurée, et

  • Testé et mis à l’échelle de l’application

Vous pouvez toujours vous reporter à la App Engine documentation de Google]pour plus d’informations.

Comme toujours, le code source complet de nos exemples est over sur GitHub .

Related