Migrera Spring Boot program till Azure App Service

  • Artikel
  • 9 minuter för att läsa

Den här guiden beskriver vad du bör känna till när du vill migrera ett befintligt Spring Boot-program till Azure App Service.

Före migrering

För att säkerställa en lyckad migrering slutför du utvärderings- och inventeringsstegen som beskrivs i följande avsnitt innan du börjar.

Om du inte kan uppfylla något av dessa krav före migreringen kan du gå till följande kompletterande migreringsguider:

  • Migrera körbara JAR-program till containrar Azure Kubernetes Service (planerad vägledning)
  • Migrera körbara JAR-program till Azure Virtual Machines (planerad vägledning)

Växla till en plattform som stöds

App Service erbjuder vissa versioner av Java SE. Säkerställ kompatibiliteten genom att migrera programmet till en av de versioner som stöds i den aktuella miljön innan du fortsätter med något av de återstående stegen. Var noga med att testa den resulterande konfigurationen fullt ut. Använd den senaste stabila versionen av Linux-distributionen i sådana tester.

Anteckning

Den här verifieringen är särskilt viktig om den aktuella servern körs på en JDK som inte stöds (till exempel Oracle JDK eller IBM OpenJ9).

Du får den aktuella Java-versionen genom att logga in på din produktionsserver och köra följande kommando:

java -version

Hämta den aktuella versionen som används av Azure App Service genom att ladda ned Zulu 8 om du tänker använda Java 8-runtime eller Zulu 11 om du tänker använda Java 11-runtime.

Inventera externa resurser

Identifiera externa resurser, till exempel datakällor, asynkrona JMS-meddelandetjänster och URL:er för andra tjänster. I Spring Boot program hittar du vanligtvis konfigurationen för sådana resurser i mappen src/main/directory i en fil som vanligtvis kallas application.properties eller application.yml. Dessutom kontrollerar du miljövariablerna för produktionsdistributionen för alla relevanta konfigurationsinställningar.

Databaser

Identifiera anslutningssträngen för alla SQL-databaser.

För ett Spring Boot-program visas anslutningssträngar vanligtvis i konfigurationsfiler.

Här är ett exempel från en application.properties-fil:

spring.datasource.url=jdbc:mysql://localhost:3306/mysql_db
spring.datasource.username=dbuser
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

Här är ett exempel från en application.properties-fil:

spring:
  data:
    mongodb:
      uri: mongodb://mongouser:deepsecret@mongoserver.contoso.com:27017

Mer möjliga konfigurationsscenarier finns i Spring Data-dokumentationen:

JMS-meddelandekoordinatorer

Identifiera den a broker eller brokers som används genom att titta i byggmanifestet (vanligtvis en pom.xml- eller build.gradle-fil) för relevanta beroenden.

Till exempel skulle ett Spring Boot program som använder ActiveMQ vanligtvis innehålla det här beroendet i pom.xml fil:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-activemq</artifactId>
</dependency>

Spring Boot-program som använder asynkron meddelandeköer med äganderätt innehåller vanligtvis beroenden direkt på drivrutinsbiblioteket för JMS. Här är ett exempel från en build.gradle-fil:

    dependencies {
      ...
      compile("com.ibm.mq:com.ibm.mq.allclient:9.0.4.0")
      ...
    }

När du har identifierat den a broker eller brokers som används hittar du motsvarande inställningar. I Spring Boot program hittar du dem vanligtvis i filerna application.properties och application.yml i programkatalogen.

Här är ett ActiveMQ-exempel från en application.properties-fil:

spring.activemq.brokerurl=broker:(tcp://localhost:61616,network:static:tcp://remotehost:61616)?persistent=false&useJmx=true
spring.activemq.user=admin
spring.activemq.password=tryandguess

Mer information om ActiveMQ-konfiguration finns i dokumentationen Spring Boot meddelanden.

Här är ett IBM MQ-exempel från en application.yaml-fil:

ibm:
  mq:
    queueManager: qm1
    channel: dev.ORDERS
    connName: localhost(14)
    user: admin
    password: big$ecr3t

Mer information om IBM MQ-konfiguration finns i dokumentationen för IBM MQ Spring-komponenter.

Identifiera externa cacheminnen

Identifiera eventuella externa cacheminnen som används. Redis används ofta via Spring Data Redis. Konfigurationsinformation finns i Spring Data Redis-dokumentationen.

Ta reda på om sessionsdata cachelagras via Spring Session genom att söka efter respektive konfiguration (i Java eller XML).

Identitetsprovidrar

Identifiera eventuella identitetsproviders som används av ditt program. Information om hur identitetsproviders kan konfigureras finns i följande:

Alla andra externa resurser

Det är inte möjligt att dokumentera alla möjliga externa beroenden i den här guiden. Det är ditt teams ansvar att kontrollera att varje externt beroende av ditt program kan uppfyllas efter en App Service-migrering.

Inventera hemligheter

Lösenord och säkra strängar

Kontrollera alla egenskaper och konfigurationsfiler och alla miljövariabler för produktionsdistribution (er) för eventuella hemliga strängar och lösenord. I ett Spring Boot-program finns sådana strängar förmodligen i application.properties eller application.yml.

Inventera certifikat

Dokumentera alla certifikat som används för offentliga SSL-slutpunkter eller kommunikation med serverdelsdatabaser och andra system. Du kan visa alla certifikat på produktionsservrarna genom att köra följande kommando:

keytool -list -v -keystore <path to keystore>

Avgöra om och hur filsystemet används

All användning av programserverns filsystem kräver omkonfiguration eller, i sällsynta fall, arkitektoniska ändringar. Du kanske känner igen några eller alla av följande scenarier.

Skrivskyddat statiskt innehåll

Om ditt program för tillfället hanterar statiskt innehåll behöver du en alternativ plats för det. Du kanske kan tänka dig att flytta det statiska innehållet till Azure Blob Storage och lägga till Azure CDN för blixtsnabba nedladdningar globalt. Mer information finns i Värdtjänster för statiska webbplatser i Azure Storage och Snabbstart: Integrera ett Azure-lagringskonto med Azure CDN.

Dynamiskt publicerat statiskt innehåll

Om ditt program tillåter att statiskt innehåll laddas upp/skapas av ditt program, men inte kan ändras efter att det har skapats, så kan du använda Azure Blob Storage och Azure CDN enligt beskrivningen ovan, med en Azure-funktion för hantering av överföringar och CDN-uppdateringar. Vi har tillhandahållit en exempelimplementering som du kan använda i Överföra och CDN-för inläsa statiskt innehåll med Azure Functions.

Särskilda fall

Vissa produktionsscenarier kan kräva ytterligare ändringar eller medföra ytterligare begränsningar. Även om sådana scenarier kan vara ovanliga, är det viktigt att se till att de antingen inte kan tillämpas på ditt program eller är korrekt lösta.

Avgör om programmet är beroende av schemalagda uppgifter

Schemalagda jobb, t. ex. Quartz Scheduler-uppgifter eller cron-jobb, kan inte användas med App Service. App Service hindrar dig inte från att distribuera ett program som innehåller schemalagda aktiviteter internt. Om ditt program skalas ut kan dock samma schemalagda jobb köras mer än en gång per schemalagd period. Den här situationen kan leda till oönskade konsekvenser.

Inventera schemalagda jobb, inuti eller utanför programprocessen.

Ta reda på om ditt program innehåller en OS-specifik kod

Om programmet innehåller en kod med beroenden i värdoperativsystemet måste du ta bort dessa beroenden genom att återanvända den. Du kan exempelvis bli tvungen att ersätta all användning av / eller \ i filsystemets sökvägar med File.Separator eller Paths.get.

Identifiera alla externa processer/daemonar som körs på produktionsservrarna

Du kommer att behöva migrera någon annanstans eller eliminera alla processer som körs utanför programservern, som exempelvis övervakningsdaemoner.

Identifiera hantering av icke-HTTP-förfrågningar eller flera portar

App Service stöder bara en enda HTTP-slutpunkt på en enda port. Om ditt program lyssnar på flera portar eller accepterar begäranden med andra protokoll än HTTP ska du inte använda Azure App Service.

Migrering

Parameterisera konfigurationen

Se till att alla externa resurskoordinater (t. ex. databasanslutningssträngar) och andra anpassningsbara inställningar kan läsas från miljövariabler. Om du migrerar en Spring Boot program bör alla konfigurationsinställningar redan vara externalizable. Mer information finns i Externaliserad konfiguration i Spring Boot dokumentationen.

Här är ett exempel som refererar till en SERVICEBUS_CONNECTION_STRING-miljövariabel från en SERVICEBUS_CONNECTION_STRING-fil:

spring.jms.servicebus.connection-string=${SERVICEBUS_CONNECTION_STRING}
spring.jms.servicebus.topic-client-id=contoso1
spring.jms.servicebus.idle-timeout=10000

Etablera en App Service-plan

I listan över tillgängliga tjänstplaner väljer du den plan vars specifikationer uppfyller eller överskrider den aktuella produktionsmaskinvarans specifikationer.

Anteckning

Om du planerar att köra mellanlagrings-/kanariedistributioner eller använda distributionsfack måste App Service plan inkludera den ytterligare kapaciteten. Vi rekommenderar att du använder Premium-plan eller högre för Java-program.

Skapa App Service-planen.

Skapa och distribuera webbappar

Du måste skapa en webbapp i din App Service-plan (du väljer Java SE som körningsstack) för varje körbar JAR-fil som du vill köra.

Maven-program

Om programmet har skapats från en Maven POM-fil, så skapa webbappen och distribuera ditt program genom att använda webbapps-plugin-programmet för Maven. Mer information finns i Snabbstart: Skapa en Java-app på Azure App Service.

Andra program än Maven-program

Om du inte kan använda Maven-plugin-programmet måste du etablera webbappen med andra medel, som exempelvis:

När webbappen har skapats kan du distribuera programmet genom att använda någon av de tillgängliga distributionsmetoderna. Om möjligt bör ditt program laddas upp till /Home/site/wwwroot/app.jar. Om du inte vill byta namn på jar-filen till app.jarkan du ladda upp ett kommandoskript med kommandot för att köra jar-filen. Klistra sedan in den fullständiga sökvägen till skriptet i textrutan Startfil i konfigurationsavsnittet i portalen. Startskriptet körs inte från katalogen där det placeras. Använd därför alltid absoluta sökvägar för att referera till filer i startskriptet (till exempel: java -jar /home/myapp/myapp.jar).

Migrera JVM-körningsalternativen

Om ditt program kräver specifika körningsalternativ, så använd den lämpligaste metoden för att ange dem.

Aktivera anpassad domän SSL

Om programmet ska vara synligt i en anpassad domän måste du mappa ditt webbprogram till det. Mer information finns i Självstudie: Mappa ett befintligt anpassat DNS-namn till Azure App Service.

Sedan måste du binda SSL-certifikatet för den domänen till din App Service-webbapp. Mer information finns i Skydda ett anpassat DNS-namn med en SSL-bindning i Azure App Service.

Importera serverdelscertifikat

Alla certifikat för att kommunicera med serverdelssystem, t. ex. databaser, måste göras tillgängliga för App Service. Mer information finns i Lägga till ett SSL-certifikat i App Service.

Migrera externa resurskoordinater och andra inställningar

Följ de här stegen för att migrera anslutningssträngar och andra inställningar.

Anteckning

För alla Spring Boot-programinställningar som har parametriserats i avsnittet Parametrisera konfiguration måste dessa miljövariabler definieras i programkonfigurationen. Alla inställningar för att starta program som inte uttryckligen parametriseras med miljövariabler kan fortfarande åsidosättas av dessa via programkonfigurationen. Till exempel:

spring.jms.servicebus.connection-string=${CUSTOMCONNSTR_SERVICE_BUS}
spring.jms.servicebus.topic-client-id=contoso1
spring.jms.servicebus.idle-timeout=1800000

Programkonfiguration för apptjänsten

Migrera schemalagda jobb

Om du vill köra schemalagda jobb på Azure bör du överväga att använda en Timer-utlösare för Azure Functions. Du behöver inte migrera själva jobbkoden till en funktion. Funktionen kan helt enkelt anropa en URL i ditt program för att utlösa jobbet. Om sådana jobb körningar måste anropas dynamiskt och/eller spåras centralt, bör du överväga att använda Spring Batch.

Du kan även skapa en logikapp med en upprepningsutlösare för att anropa URL:en utan att skriva någon kod utanför programmet. Mer information finns i Översikt – vad är Azure Logic Apps? och Skapa, Schemalägga och köra återkommande uppgifter och arbetsflöden med upprepningsutlösaren i Azure Logic Apps.

Anteckning

För att förhindra skadlig användning måste du förmodligen se till att jobbanropets slutpunkt kräver autentiseringsuppgifter. I det här fallet måste utlösarfunktionen ange autentiseringsuppgifterna.

Migrera och aktivera identitetsprovidern

Om ditt program kräver autentisering eller auktorisering, se till att de är konfigurerade för att få åtkomst till identitetsprovidern med hjälp av följande riktlinjer:

  • Om identitetsprovidern Azure Active Directory behöver du inte göra några ändringar.
  • Om identitetsprovidern är en lokal Active Directory bör du överväga att implementera en hybrididentitetslösning Azure Active Directory. Mer information finns i dokumentationen om hybrididentiteter.
  • Om identitetsprovidern är en annan lokal lösning, till exempel PingFederate, kan du läsa avsnittet Anpassad installation av Azure AD Anslut för att konfigurera federation med Azure Active Directory. Du kan också överväga att använda Spring Security för att använda din identitetsprovider via OAuth2/OpenID Anslut eller SAML.

Starta om och röktesta

Slutligen måste du starta om din webbapp, så att alla konfigurationsändringar tillämpas. När omstarten är klar kontrollerar du att programmet fungerar som det ska.

Efter migreringen

Nu när du har migrerat ditt program till Azure App Service bör du kontrollera att det fungerar som förväntat. När du har gjort det har vi några rekommendationer för dig som kan göra ditt program lämpligare för molnet.

Rekommendationer