Distribuera ett Java-program med WebLogic Server i ett AKS-kluster (Azure Kubernetes Service)

Artikel
02/21/2024

Den här artikeln visar hur du:

Kör Java, Java EE eller Jakarta EE på Oracle WebLogic Server (WLS).
Skapa ett WLS-kluster med hjälp av Azure Marketplace-erbjudandet.
Skapa docker-avbildningen för att fungera som extra avbildning för att tillhandahålla WDT-modeller (WebLogic Deploy Tooling) och -program.
Distribuera det containerbaserade programmet till det befintliga WLS-klustret i AKS med anslutning till Microsoft Azure SQL.

Den här artikeln använder Azure Marketplace-erbjudandet för WLS för att påskynda din resa till AKS. Erbjudandet etablerar automatiskt flera Azure-resurser, inklusive följande resurser:

En Azure Container Registry-instans
Ett AKS-kluster
En Ingresskontrollant för Azure App Gateway (AGIC)
WebLogic-operatorn
En containeravbildning inklusive WebLogic-körningen
Ett WLS-kluster utan program

Den här artikeln beskriver sedan hur du skapar en extra avbildning steg för steg för att uppdatera ett befintligt WLS-kluster. Den extra avbildningen innehåller program- och WDT-modeller.

För fullständig automatisering kan du välja ditt program och konfigurera datakällans anslutning från Azure-portalen innan erbjudandet distribueras. Om du vill se erbjudandet går du till Azure-portalen.

Stegvisa anvisningar för hur du konfigurerar WebLogic Server på Azure Kubernetes Service finns i den officiella dokumentationen från Oracle på Azure Kubernetes Service.

Förutsättningar

Om du inte har en Azure-prenumeration skapar du ett kostnadsfritt Azure-konto innan du börjar.
Kontrollera att den Azure-identitet som du använder för att logga in och slutföra den här artikeln har rollen Ägare i den aktuella prenumerationen eller rollen Deltagare och Administratör för användaråtkomst i den aktuella prenumerationen. En översikt över Azure-roller finns i Vad är rollbaserad åtkomstkontroll i Azure (Azure RBAC)? Mer information om de specifika roller som krävs av WLS i AKS finns i Inbyggda Roller i Azure.
Ha autentiseringsuppgifterna för ett Oracle-konto för enkel inloggning (SSO). Information om hur du skapar ett finns i Skapa ditt Oracle-konto.
Godkänn licensvillkoren för WLS.
- Besök Oracle Container Registry och logga in.
- Om du har en stödrättighet väljer du Mellanprogram och söker sedan efter och väljer weblogic_cpu.
- Om du inte har någon stödrättighet från Oracle väljer du Mellanprogram och söker sedan efter och väljer weblogic.
  
  Kommentar
  
  Skaffa en supporträttighet från Oracle innan du går till produktion. Om du inte gör det körs osäkra avbildningar som inte har korrigerats för kritiska säkerhetsbrister. Mer information om Oracles kritiska korrigeringsuppdateringar finns i Kritiska korrigeringar Uppdateringar, säkerhetsaviseringar och bulletiner från Oracle.
- Godkänn licensavtalet.
Förbered en lokal dator med Unix-liknande operativsystem installerat (till exempel Ubuntu, Azure Linux, macOS, Windows-undersystem för Linux).
- Azure CLI. Använd az --version för att testa om az fungerar. Det här dokumentet har testats med version 2.55.1.
- Docker. Det här dokumentet testades med Docker version 20.10.7. Använd docker info för att testa om Docker Daemon körs.
- kubectl. Använd kubectl version för att testa om kubectl fungerar. Det här dokumentet testades med version v1.21.2.
- Ett Java JDK som är kompatibelt med den version av WLS som du tänker köra. I artikeln uppmanas du att installera en version av WLS som använder JDK 11. Azure rekommenderar Microsoft Build of OpenJDK. Kontrollera att miljövariabeln JAVA_HOME är korrekt inställd i de gränssnitt där du kör kommandona.
- Maven 3.5.0 eller senare.
- Kontrollera att zip/unzip-verktyget är installerat. Använd zip/unzip -v för att testa om zip/unzip fungerar.
Alla steg i den här artikeln, förutom de som gäller Docker, kan också köras i Azure Cloud Shell. Mer information om Azure Cloud Shell finns i Vad är Azure Cloud Shell?

Distribuera WLS på AKS

Stegen i det här avsnittet instruerar dig att distribuera WLS på AKS på enklast möjliga sätt. WLS på AKS erbjuder ett brett och djupt urval av Azure-integreringar. Mer information finns i Vad är lösningar för att köra Oracle WebLogic Server på Azure Kubernetes Service?

Följande steg visar hur du hittar WLS på AKS-erbjudandet och fyller i fönstret Grundläggande .

I sökfältet överst i Azure-portalen anger du weblogic. I det automatiskt föreslagna sökresultatet går du till avsnittet Marketplace och väljer WebLogic Server på AKS.

Du kan också gå direkt till WebLogic Server på AKS-erbjudandet .
På erbjudandesidan väljer du Skapa.
I fönstret Grundläggande kontrollerar du att värdet som visas i fältet Prenumeration är samma som du loggade in på i Azure. Kontrollera att du har rollerna listade i avsnittet förutsättningar.
Du måste distribuera erbjudandet i en tom resursgrupp. I fältet Resursgrupp väljer du Skapa ny och fyller sedan i ett värde för resursgruppen. Eftersom resursgrupper måste vara unika i en prenumeration väljer du ett unikt namn. Ett enkelt sätt att få unika namn är att använda en kombination av dina initialer, dagens datum och någon identifierare – till exempel ejb0723wls.
Under Instansinformation väljer du regionen för distributionen. En lista över Azure-regioner där AKS är tillgängligt finns i TILLGÄNGLIGHET för AKS-regioner.
Under Autentiseringsuppgifter för WebLogic lämnar du standardvärdet för Användarnamn för WebLogic-administratör.
Fyll i wlsAksCluster2022 för Lösenordet för WebLogic-administratören. Använd samma värde för krypteringsfälten för bekräftelse och lösenord för WebLogic Model .
Rulla längst ned i fönstret Grundläggande och lägg märke till de användbara länkarna för dokumentation, communitysupport och hur du rapporterar problem.
Välj Nästa.

Följande steg visar hur du startar distributionsprocessen.

Rulla till avsnittet med etiketten Ange ett Oracle-konto för enkel inloggning (SSO). Fyll i dina Oracle SSO-autentiseringsuppgifter från förhandsvillkoren.
Följ stegen i informationsrutan som börjar med Innan du går vidare måste du godkänna Oracles standardvillkor och begränsningar.
Beroende på om Oracle SSO-kontot har en Oracle-stödrättighet eller inte väljer du lämpligt alternativ för Välj typ av WebLogic Server-avbildningar.. Om kontot har en stödrättighet väljer du Korrigerade WebLogic Server-avbildningar. Annars väljer du Allmänna WebLogic Server-avbildningar.
Lämna värdet i Välj önskad kombination av WebLogic Server... som standardvärde. Du har ett brett utbud av alternativ för WLS-, JDK- och OS-version.
I avsnittet Program bredvid Distribuera ett program?, väljer du Nej.

Följande steg gör det så att WLS-administratörskonsolen och exempelappen exponeras för det offentliga Internet med ett inbyggt Application Gateway-tillägg. Mer information finns i Vad är Application Gateway Ingress Controller?

Välj Nästa för att se TLS/SSL-fönstret .
Välj Nästa för att se fönstret Belastningsutjämning .
Bredvid Alternativ för belastningsutjämning väljer du Application Gateway-ingresskontrollant.
Under Application Gateway-ingresskontrollanten bör du se alla fält ifyllda med standardvärdena för virtuellt nätverk och undernät. Låt standardvärdena vara kvar.
För Skapa ingress för administrationskonsolen väljer du Ja.
Lämna standardvärdena för andra fält.
Välj Granska + skapa. Kontrollera att verifieringen inte misslyckas. Om det misslyckas kan du åtgärda eventuella valideringsproblem och sedan välja Granska + skapa igen.
Välj Skapa.
Spåra förloppet för distributionen på sidan Distribution pågår .

Beroende på nätverksförhållanden och annan aktivitet i den valda regionen kan distributionen ta upp till 50 minuter att slutföra.

Du kan utföra stegen i avsnittet Skapa en Azure SQL Database medan du väntar. Gå tillbaka till det här avsnittet när du är klar med att skapa databasen.

Granska distributionsutdata

Använd stegen i det här avsnittet för att kontrollera att distributionen lyckades.

Om du har navigerat bort från sidan Distribution pågår visar följande steg hur du kommer tillbaka till den sidan. Om du fortfarande är på sidan som visar Att distributionen är klar kan du gå vidare till steg 5 efter nästa skärmbild.

I hörnet på en Azure-portalsida väljer du hamburgermenyn och väljer Resursgrupper.
I rutan med texten Filtrera för ett fält anger du de första tecknen i resursgruppen som du skapade tidigare. Om du följde den rekommenderade konventionen anger du dina initialer och väljer sedan lämplig resursgrupp.
I navigeringsfönstret går du till avsnittet Inställningar och väljer Distributioner. Du ser en ordnad lista över distributionerna till den här resursgruppen, med den senaste först.
Rulla till den äldsta posten i den här listan. Den här posten motsvarar den distribution som du startade i föregående avsnitt. Välj den äldsta distributionen enligt följande skärmbild.
I navigeringsfönstret väljer du Utdata. Den här listan visar utdatavärdena från distributionen. Användbar information ingår i utdata.
Värdet adminConsoleExternalUrl är den fullständigt kvalificerade, offentliga Internet-synliga länken till WLS-administratörskonsolen för det här AKS-klustret. Välj kopieringsikonen bredvid fältvärdet för att kopiera länken till Urklipp. Spara det här värdet åt sidan för senare.
ClusterExternalUrl-värdet är den fullständigt kvalificerade, offentliga Internet-synliga länken till exempelappen som distribueras i WLS i det här AKS-klustret. Välj kopieringsikonen bredvid fältvärdet för att kopiera länken till Urklipp. Spara det här värdet åt sidan för senare.
Värdet shellCmdtoOutputWlsImageModelYaml är base64-strängen i WDT-modellen som skapades i containeravbildningen. Spara det här värdet åt sidan för senare.
Värdet shellCmdtoOutputWlsImageProperties är base64-strängen med WDT-modellegenskaper som har skapats i containeravbildningen. Spara det här värdet åt sidan för senare.
Värdet shellCmdto Anslut Aks är Azure CLI-kommandot för att ansluta till det här specifika AKS-klustret. På så sätt kan du använda kubectl för att administrera klustret.

De andra värdena i utdata ligger utanför omfånget för den här artikeln, men beskrivs i detalj i användarhandboken för WebLogic i AKS.

Skapa en Azure SQL Database

Om du vill skapa en enkel Azure SQL Database-databas för användning med din app följer du stegen i Snabbstart: Skapa en enkel databas i Azure SQL Database. Observera noggrant följande skillnader:

I steget Grundläggande skriver du ned värdena för resursgrupp, databasnamn, <servernamn.database.windows.net>, inloggning för serveradministratör och lösenord. Den här artikeln refererar till databasens resursgruppsvärde som <db-resource-group>.
I nätverkssteget anger du Anslut ivity-metoden till Offentlig slutpunkt, anger Tillåt Att Azure-tjänster och resurser får åtkomst till den här servern till Ja och anger Lägg till aktuell klient-IP-adress till Ja.

Kommentar

Den serverlösa beräkningsnivå som du valde för den här databasen sparar pengar genom att placera databasen i viloläge under perioder av inaktivitet. Exempelappen misslyckas om databasen är i viloläge när appen startas.

Om du vill tvinga databasen att aktiveras kan du köra en fråga med hjälp av frågeredigeraren. Följ stegen i Fråga databasen. Här är en exempelfråga: SELECT * FROM COFFEE;.

Skapa ett schema för exempelprogrammet. Följ Fråga databasen för att öppna fönstret Frågeredigeraren . Ange och kör följande fråga:
```
CREATE TABLE COFFEE (ID NUMERIC(19) NOT NULL, NAME VARCHAR(255) NULL, PRICE FLOAT(32) NULL, PRIMARY KEY (ID));
CREATE TABLE SEQUENCE (SEQ_NAME VARCHAR(50) NOT NULL, SEQ_COUNT NUMERIC(28) NULL, PRIMARY KEY (SEQ_NAME));
INSERT INTO SEQUENCE VALUES ('SEQ_GEN',0);
```
Efter en lyckad körning bör du se meddelandet Fråga lyckades: Berörda rader: 0. Om du inte ser det här meddelandet kan du felsöka och lösa problemet innan du fortsätter.

Databasen, tabellerna, AKS-klustret och WLS-klustret skapas. Om du vill kan du utforska administratörskonsolen genom att öppna en webbläsare och navigera till adressen till adminConsoleExternalUrl. Logga in med de värden som du angav under WLS i AKS-distributionen.

Du kan fortsätta med att förbereda AKS som värd för ditt WebLogic-program.

Konfigurera och distribuera exempelprogrammet

Erbjudandet etablerar WLS-klustret via modellen i avbildningen. För närvarande har WLS-klustret inget distribuerat program.

Det här avsnittet uppdaterar WLS-klustret genom att distribuera ett exempelprogram med hjälp av en extra avbildning.

Kolla in programmet

I det här avsnittet klonar du exempelkoden för den här guiden. Exemplet finns på GitHub på lagringsplatsen weblogic-on-azure i mappen javaee/weblogic-café/ . Här är programmets filstruktur.

weblogic-cafe
├── pom.xml
└── src
    └── main
        ├── java
        │   └── cafe
        │       ├── model
        │       │   ├── CafeRepository.java
        │       │   └── entity
        │       │       └── Coffee.java
        │       └── web
        │           ├── rest
        │           │   └── CafeResource.java
        │           └── view
        │               └── Cafe.java
        ├── resources
        │   ├── META-INF
        │   │   └── persistence.xml
        │   └── cafe
        │       └── web
        │           ├── messages.properties
        │           └── messages_es.properties
        └── webapp
            ├── WEB-INF
            │   ├── beans.xml
            │   ├── faces-config.xml
            │   └── web.xml
            ├── index.xhtml
            └── resources
                └── components
                    └── inputPrice.xhtml

Använd följande kommandon för att klona lagringsplatsen:

cd <parent-directory-to-check-out-sample-code>
export BASE_DIR=$PWD
git clone --single-branch https://github.com/microsoft/weblogic-on-azure.git --branch 20240201 $BASE_DIR/weblogic-on-azure

Om du ser ett meddelande om att vara i "frånkopplat HEAD"-tillstånd är det här meddelandet säkert att ignorera. Det betyder bara att du checkade ut en tagg.

Använd följande kommando för att skapa javaee/weblogic-café/:

mvn clean package --file $BASE_DIR/weblogic-on-azure/javaee/weblogic-cafe/pom.xml

Paketet ska genereras och finnas på $BASE_DIR/weblogic-on-azure/javaee/weblogic-café/target/weblogic-café.war. Om du inte ser paketet måste du felsöka och lösa problemet innan du fortsätter.

Använda Docker för att skapa en extra avbildning

Stegen i det här avsnittet visar hur du skapar en extra avbildning. Den här avbildningen innehåller följande komponenter:

Modell i bildmodellfiler
Ditt program
JDBC-drivrutinsarkivfilen
Installationen av WebLogic Deploy Tooling

En extra avbildning är en Docker-containeravbildning som innehåller din app och konfiguration. WebLogic Kubernetes-operatorn kombinerar din extra avbildning med domain.spec.image i AKS-klustret som innehåller WebLogic Server, JDK och operativsystemet. Mer information om extra bilder finns i Hjälpbilder i Oracle-dokumentationen.

Det här avsnittet kräver en Linux-terminal med Azure CLI och kubectl installerat.

Använd följande steg för att skapa avbildningen:

Använd följande kommandon för att skapa en katalog för att mellanlagra modellerna och programmet:
```
mkdir -p ${BASE_DIR}/mystaging/models
cd ${BASE_DIR}/mystaging/models
```

Kopiera shellCmdtoOutputWlsImageModelYaml-värdet som du sparade från distributionsutdata, klistra in det i Bash-fönstret och kör kommandot. Kommandot bör se ut ungefär som i följande exempel:

echo -e IyBDb3B5cmlna...Cgo= | base64 -d > model.yaml

Det här kommandot genererar en ${BASE_DIR}/mystaging/models/model.yaml-fil med innehåll som liknar följande exempel:

# Copyright (c) 2020, 2021, Oracle and/or its affiliates.
# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.

# Based on ./kubernetes/samples/scripts/create-weblogic-domain/model-in-image/model-images/model-in-image__WLS-v1/model.10.yaml
# in https://github.com/oracle/weblogic-kubernetes-operator.

domainInfo:
  AdminUserName: "@@SECRET:__weblogic-credentials__:username@@"
  AdminPassword: "@@SECRET:__weblogic-credentials__:password@@"
  ServerStartMode: "prod"

topology:
  Name: "@@ENV:CUSTOM_DOMAIN_NAME@@"
  ProductionModeEnabled: true
  AdminServerName: "admin-server"
  Cluster:
    "cluster-1":
      DynamicServers:
        ServerTemplate: "cluster-1-template"
        ServerNamePrefix: "@@ENV:MANAGED_SERVER_PREFIX@@"
        DynamicClusterSize: "@@PROP:CLUSTER_SIZE@@"
        MaxDynamicClusterSize: "@@PROP:CLUSTER_SIZE@@"
        MinDynamicClusterSize: "0"
        CalculatedListenPorts: false
  Server:
    "admin-server":
      ListenPort: 7001
  ServerTemplate:
    "cluster-1-template":
      Cluster: "cluster-1"
      ListenPort: 8001
  SecurityConfiguration:
    NodeManagerUsername: "@@SECRET:__weblogic-credentials__:username@@"
    NodeManagerPasswordEncrypted: "@@SECRET:__weblogic-credentials__:password@@"

resources:
  SelfTuning:
    MinThreadsConstraint:
      SampleMinThreads:
        Target: "cluster-1"
        Count: 1
    MaxThreadsConstraint:
      SampleMaxThreads:
        Target: "cluster-1"
        Count: 10
    WorkManager:
      SampleWM:
        Target: "cluster-1"
        MinThreadsConstraint: "SampleMinThreads"
        MaxThreadsConstraint: "SampleMaxThreads"

På liknande sätt kopierar du värdet shellCmdtoOutputWlsImageProperties , klistrar in det i Bash-fönstret och kör kommandot. Kommandot bör se ut ungefär som i följande exempel:

echo -e IyBDb3B5cml...pFPTUK | base64 -d > model.properties

Det här kommandot genererar filen ${BASE_DIR}/mystaging/models/model.properties med innehåll som liknar följande exempel:

# Copyright (c) 2021, Oracle Corporation and/or its affiliates.
# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.

# Based on ./kubernetes/samples/scripts/create-weblogic-domain/model-in-image/model-images/model-in-image__WLS-v1/model.10.properties
# in https://github.com/oracle/weblogic-kubernetes-operator.

CLUSTER_SIZE=5

Använd följande steg för att skapa programmodellfilen.

Använd följande kommandon för att kopiera weblogic-café.war och spara det i wlsdeploy/applications:

mkdir -p ${BASE_DIR}/mystaging/models/wlsdeploy/applications
cp $BASE_DIR/weblogic-on-azure/javaee/weblogic-cafe/target/weblogic-cafe.war ${BASE_DIR}/mystaging/models/wlsdeploy/applications/weblogic-cafe.war

Använd följande kommandon för att skapa programmodellfilen med det innehåll som visas. Spara modellfilen till ${BASE_DIR}/mystaging/models/appmodel.yaml.

cat <<EOF >appmodel.yaml
appDeployments:
  Application:
    weblogic-cafe:
      SourcePath: 'wlsdeploy/applications/weblogic-cafe.war'
      ModuleType: ear
      Target: 'cluster-1'
EOF

Använd följande kommandon för att ladda ned och installera Microsoft SQL Server JDBC-drivrutinen till wlsdeploy/externalJDBCLibraries:

export DRIVER_VERSION="10.2.1.jre8"
export MSSQL_DRIVER_URL="https://repo.maven.apache.org/maven2/com/microsoft/sqlserver/mssql-jdbc/${DRIVER_VERSION}/mssql-jdbc-${DRIVER_VERSION}.jar"

mkdir ${BASE_DIR}/mystaging/models/wlsdeploy/externalJDBCLibraries
curl -m 120 -fL ${MSSQL_DRIVER_URL} -o ${BASE_DIR}/mystaging/models/wlsdeploy/externalJDBCLibraries/mssql-jdbc-${DRIVER_VERSION}.jar

Använd sedan följande kommandon för att skapa databasanslutningsmodellfilen med det innehåll som visas. Spara modellfilen till ${BASE_DIR}/mystaging/models/dbmodel.yaml. Modellen använder platshållare (hemlighet sqlserver-secret) för databasanvändarnamn, lösenord och URL. Kontrollera att följande fält har angetts korrekt. Följande modell namnger resursen med jdbc/WebLogicCafeDB.

Objektnamn	Fält	Värde
JNDI-namn	`resources.JDBCSystemResource.<resource-name>.JdbcResource.JDBCDataSourceParams.JNDIName`	`jdbc/WebLogicCafeDB`
Drivrutinsnamn	`resources.JDBCSystemResource.<resource-name>.JDBCDriverParams.DriverName`	`com.microsoft.sqlserver.jdbc.SQLServerDriver`
Databas-URL	`resources.JDBCSystemResource.<resource-name>.JDBCDriverParams.URL`	`@@SECRET:sqlserver-secret:url@@`
Databaslösenord	`resources.JDBCSystemResource.<resource-name>.JDBCDriverParams.PasswordEncrypted`	`@@SECRET:sqlserver-secret:password@@`
Databasanvändarnamn	`resources.JDBCSystemResource.<resource-name>.JDBCDriverParams.Properties.user.Value`	`'@@SECRET:sqlserver-secret:user@@'`

cat <<EOF >dbmodel.yaml
resources:
  JDBCSystemResource:
    jdbc/WebLogicCafeDB:
      Target: 'cluster-1'
      JdbcResource:
        JDBCDataSourceParams:
          JNDIName: [
            jdbc/WebLogicCafeDB
          ]
          GlobalTransactionsProtocol: None
        JDBCDriverParams:
          DriverName: com.microsoft.sqlserver.jdbc.SQLServerDriver
          URL: '@@SECRET:sqlserver-secret:url@@'
          PasswordEncrypted: '@@SECRET:sqlserver-secret:password@@'
          Properties:
            user:
              Value: '@@SECRET:sqlserver-secret:user@@'
        JDBCConnectionPoolParams:
          TestTableName: SQL SELECT 1
          TestConnectionsOnReserve: true
EOF

Använd följande kommandon för att skapa en programarkivfil och ta sedan bort mappen wlsdeploy , som du inte behöver längre:
```
cd ${BASE_DIR}/mystaging/models
zip -r archive.zip wlsdeploy

rm -f -r wlsdeploy
```

Använd följande kommandon för att ladda ned och installera WebLogic Deploy Tooling (WDT) i mellanlagringskatalogen och ta bort dess weblogic-deploy/bin/*.cmd-filer , som inte används i UNIX-miljöer:

cd ${BASE_DIR}/mystaging
curl -m 120 -fL https://github.com/oracle/weblogic-deploy-tooling/releases/latest/download/weblogic-deploy.zip -o weblogic-deploy.zip

unzip weblogic-deploy.zip -d .
rm ./weblogic-deploy/bin/*.cmd

Använd följande kommando för att ta bort WDT-installationsprogrammet:
```
rm weblogic-deploy.zip
```

Använd följande kommandon för att skapa en extra avbildning med docker:

cd ${BASE_DIR}/mystaging
cat <<EOF >Dockerfile
FROM busybox
ARG AUXILIARY_IMAGE_PATH=/auxiliary
ARG USER=oracle
ARG USERID=1000
ARG GROUP=root
ENV AUXILIARY_IMAGE_PATH=\${AUXILIARY_IMAGE_PATH}
RUN adduser -D -u \${USERID} -G \$GROUP \$USER
# ARG expansion in COPY command's --chown is available in docker version 19.03.1+.
# For older docker versions, change the Dockerfile to use separate COPY and 'RUN chown' commands.
COPY --chown=\$USER:\$GROUP ./ \${AUXILIARY_IMAGE_PATH}/
USER \$USER
EOF

docker buildx build Kör kommandot med hjälp av ${BASE_DIR}/mystaging/Dockerfile, som du ser i följande exempel:

cd ${BASE_DIR}/mystaging
docker buildx build --platform linux/amd64 --build-arg AUXILIARY_IMAGE_PATH=/auxiliary --tag model-in-image:WLS-v1 .

När du skapar avbildningen ser utdata ut ungefär som i följande exempel:

[+] Building 12.0s (8/8) FINISHED                                   docker:default
=> [internal] load build definition from Dockerfile                          0.8s
=> => transferring dockerfile: 473B                                          0.0s
=> [internal] load .dockerignore                                             1.1s
=> => transferring context: 2B                                               0.0s
=> [internal] load metadata for docker.io/library/busybox:latest             5.0s
=> [1/3] FROM docker.io/library/busybox@sha256:6d9ac9237a84afe1516540f40a0f  0.0s
=> [internal] load build context                                             0.3s
=> => transferring context: 21.89kB                                          0.0s
=> CACHED [2/3] RUN adduser -D -u 1000 -G root oracle                        0.0s
=> [3/3] COPY --chown=oracle:root ./ /auxiliary/                             1.5s
=> exporting to image                                                        1.3s
=> => exporting layers                                                       1.0s
=> => writing image sha256:2477d502a19dcc0e841630ea567f50d7084782499fe3032a  0.1s
=> => naming to docker.io/library/model-in-image:WLS-v1                      0.2s

Om du har skapat avbildningen bör den nu finnas på den lokala datorns Docker-lagringsplats. Du kan kontrollera att avbildningen har skapats med hjälp av följande kommando:
```
docker images model-in-image:WLS-v1
```
Det här kommandot bör generera utdata som liknar följande exempel:
```
REPOSITORY       TAG       IMAGE ID       CREATED       SIZE
model-in-image   WLS-v1    76abc1afdcc6   2 hours ago   8.61MB
```
När avbildningen har skapats bör den ha körbara WDT-filer i /auxiliary/weblogic-deploy och WDT-modell, egenskap och arkivfiler i /auxiliary/models. Använd följande kommando på Docker-avbildningen för att verifiera det här resultatet:
```
docker run -it --rm model-in-image:WLS-v1 find /auxiliary -maxdepth 2 -type f -print
```
Det här kommandot bör generera utdata som liknar följande exempel:
```
/auxiliary/models/model.properties
/auxiliary/models/dbmodel.yaml
/auxiliary/models/model.yaml
/auxiliary/models/archive.zip
/auxiliary/models/appmodel.yaml
/auxiliary/Dockerfile
/auxiliary/weblogic-deploy/LICENSE.txt
/auxiliary/weblogic-deploy/VERSION.txt
```
Använd följande steg för att skicka den extra avbildningen till Azure Container Registry:
1. Öppna Azure-portalen och gå till den resursgrupp som du etablerade i avsnittet Distribuera WSL på AKS .
2. Välj resursen av typen Container registry i resurslistan.
3. Hovra musen över värdet bredvid Inloggningsservern och välj kopieringsikonen bredvid texten.
4. Spara värdet i ACR_LOGIN_SERVER miljövariabeln med hjälp av följande kommando:
```
export ACR_LOGIN_SERVER=<value-from-clipboard>
```
5. Kör följande kommandon för att tagga och push-överföra avbildningen. Kontrollera att Docker körs innan du kör dessa kommandon.
```
export ACR_NAME=$(echo ${ACR_LOGIN_SERVER} | cut -d '.' -f 1)
az acr login -n $ACR_NAME
docker tag model-in-image:WLS-v1 $ACR_LOGIN_SERVER/wlsaks-auxiliary-image:1.0
docker push $ACR_LOGIN_SERVER/wlsaks-auxiliary-image:1.0
```
6. Du kan köra az acr repository show för att testa om avbildningen skickas till fjärrlagringsplatsen, som du ser i följande exempel:
```
az acr repository show --name ${ACR_NAME} --image wlsaks-auxiliary-image:1.0
```
  Det här kommandot bör generera utdata som liknar följande exempel:
```
{
  "changeableAttributes": {
    "deleteEnabled": true,
    "listEnabled": true,
    "readEnabled": true,
    "writeEnabled": true
  },
  "createdTime": "2024-01-24T06:14:19.4546321Z",
  "digest": "sha256:a1befbefd0181a06c6fe00848e76f1743c1fecba2b42a975e9504ba2aaae51ea",
  "lastUpdateTime": "2024-01-24T06:14:19.4546321Z",
  "name": "1.0",
  "quarantineState": "Passed",
  "signed": false
}
```

Använd extrabilden

I föregående steg skapade du den extra avbildningen, inklusive modeller och WDT. Innan du tillämpar den extra avbildningen på WLS-klustret använder du följande steg för att skapa hemligheten för datakällans URL, användarnamn och lösenord. Hemligheten används som en del av platshållaren i dbmodel.yaml.

Anslut till AKS-klustret genom att kopiera värdet shellCmdto Anslut Aks som du sparade åt sidan tidigare, klistra in det i Bash-fönstret och sedan köra kommandot. Kommandot bör se ut ungefär som i följande exempel:
```
az account set --subscription <subscription>; 
az aks get-credentials \
    --resource-group <resource-group> \
    --name <name>
```
Du bör se utdata som liknar följande exempel. Om du inte ser dessa utdata kan du felsöka och lösa problemet innan du fortsätter.
```
Merged "<name>" as current context in /Users/<username>/.kube/config
```

Använd följande steg för att hämta värden för variablerna som visas i följande tabell. Du använder dessa värden senare för att skapa hemligheten för datakällans anslutning.

Olika	beskrivning	Exempel
`DB_CONNECTION_STRING`	SQL-serverns anslutningssträng.	`jdbc:sqlserver://server-name.database.windows.net:1433;database=wlsaksquickstart0125`
`DB_USER`	Användarnamnet för att logga in på SQL-servern.	`welogic@sqlserverforwlsaks`
`DB_PASSWORD`	Lösenordet för att logga in på sQL-servern.	`Secret123456`

Besök SQL-databasresursen i Azure-portalen.
I navigeringsfönstret under Inställningar väljer du Anslut ionssträngar.
Välj fliken JDBC .
Välj kopieringsikonen för att kopiera anslutningssträng till Urklipp.
För DB_CONNECTION_STRINGanvänder du hela anslutningssträng, men ersätter platshållaren {your_password_here} med ditt databaslösenord.
För DB_USERanvänder du delen av anslutningssträng från azureuser upp till men inte inklusive ;password={your_password_here}.
För DB_PASSWORDanvänder du det värde som du angav när du skapade databasen.

Använd följande kommandon för att skapa Kubernetes-hemligheten. Den här artikeln använder det hemliga namnet sqlserver-secret för hemligheten för datakällans anslutning. Om du använder ett annat namn kontrollerar du att värdet är detsamma som det i dbmodel.yaml.

I följande kommandon måste du ange variablerna DB_CONNECTION_STRING, DB_USERoch DB_PASSWORD korrekt genom att ersätta platshållarexemplen med de värden som beskrivs i föregående steg. Se till att omsluta värdet för variablerna DB_ med enkla citattecken för att förhindra att gränssnittet stör värdena.

export DB_CONNECTION_STRING='<example-jdbc:sqlserver://server-name.database.windows.net:1433;database=wlsaksquickstart0125>'
export DB_USER='<example-welogic@sqlserverforwlsaks>'
export DB_PASSWORD='<example-Secret123456>'
export WLS_DOMAIN_NS=sample-domain1-ns
export WLS_DOMAIN_UID=sample-domain1
export SECRET_NAME=sqlserver-secret

kubectl -n ${WLS_DOMAIN_NS} create secret generic \
    ${SECRET_NAME} \
    --from-literal=password="${DB_PASSWORD}" \
    --from-literal=url="${DB_CONNECTION_STRING}" \
    --from-literal=user="${DB_USER}"

kubectl -n ${WLS_DOMAIN_NS} label secret \
    ${SECRET_NAME} \
    weblogic.domainUID=${WLS_DOMAIN_UID}

Du måste se följande utdata innan du fortsätter. Om du inte ser dessa utdata kan du felsöka och lösa problemet innan du fortsätter.

secret/sqlserver-secret created
secret/sqlserver-secret labeled

Använd den extra avbildningen genom att korrigera domänens anpassade resursdefinition (CRD) med kommandot kubectl patch .

Den extra bilden definieras i spec.configuration.model.auxiliaryImages, som du ser i följande exempel. Mer information finns i extra bilder.

spec:
  clusters:
  - name: sample-domain1-cluster-1
  configuration:
    model:
      auxiliaryImages:
      - image: wlsaksacrafvzeyyswhxek.azurecr.io/wlsaks-auxiliary-image:1.0
        imagePullPolicy: IfNotPresent
        sourceModelHome: /auxiliary/models
        sourceWDTInstallHome: /auxiliary/weblogic-deploy

Använd följande kommandon för att öka restartVersion värdet och använda kubectl patch för att tillämpa den extra avbildningen på domänens CRD med hjälp av den definition som visas:

export VERSION=$(kubectl -n ${WLS_DOMAIN_NS} get domain ${WLS_DOMAIN_UID} -o=jsonpath='{.spec.restartVersion}' | tr -d "\"")
export VERSION=$((VERSION+1))

cat <<EOF >patch-file.json
[
  {
    "op": "replace",
    "path": "/spec/restartVersion",
    "value": "${VERSION}"
  },
  {
    "op": "add",
    "path": "/spec/configuration/model/auxiliaryImages",
    "value": [{"image": "$ACR_LOGIN_SERVER/wlsaks-auxiliary-image:1.0", "imagePullPolicy": "IfNotPresent", "sourceModelHome": "/auxiliary/models", "sourceWDTInstallHome": "/auxiliary/weblogic-deploy"}]
  },
  {
    "op": "add",
    "path": "/spec/configuration/secrets",
    "value": ["${SECRET_NAME}"]
  }
]
EOF

kubectl -n ${WLS_DOMAIN_NS} patch domain ${WLS_DOMAIN_UID} \
    --type=json \
    --patch-file patch-file.json

kubectl get pod -n ${WLS_DOMAIN_NS} -w

Vänta tills administratörsservern och hanterade servrar visar värdena i följande utdatablock innan du fortsätter:
```
NAME                             READY   STATUS    RESTARTS   AGE
sample-domain1-admin-server      1/1     Running   0          20m
sample-domain1-managed-server1   1/1     Running   0          19m
sample-domain1-managed-server2   1/1     Running   0          18m
```
Det kan ta 5–10 minuter för systemet att nå det här tillståndet. Följande lista innehåller en översikt över vad som händer medan du väntar:
- Du bör se körningen sample-domain1-introspector först. Den här programvaran söker efter ändringar i domänens anpassade resurs så att den kan vidta nödvändiga åtgärder i Kubernetes-klustret.
- När ändringar identifieras dödar domänens introspektor och startar nya poddar för att distribuera ändringarna.
- Därefter bör podden avslutas sample-domain1-admin-server och startas om.
- Sedan bör du se de två hanterade servrarna avsluta och starta om.
- Endast när alla tre poddar visar 1/1 Running tillståndet är det ok att fortsätta.

Verifiera funktionerna i distributionen

Använd följande steg för att verifiera distributionens funktioner genom att visa WLS-administratörskonsolen och exempelappen:

Klistra in värdet adminConsoleExternalUrl i adressfältet i en Internetansluten webbläsare. Du bör se inloggningsskärmen för den välbekanta WLS-administratörskonsolen.
Logga in med användarnamnet weblogic och lösenordet du angav när du distribuerade WLS från Azure-portalen. Kom ihåg att det här värdet är wlsAksCluster2022.
I rutan Domänstruktur väljer du Tjänster.
Under Tjänsterna väljer du Datakällor.
I panelen Sammanfattning av JDBC-datakällor väljer du Övervakning. Skärmen bör se ut ungefär som i följande exempel. Datakällans tillstånd körs på hanterade servrar.
I rutan Domänstruktur väljer du Distributioner.
I tabellen Distributioner bör det finnas en rad. Namnet ska vara samma värde som Application värdet i filen appmodel.yaml . Välj namnet.
I panelen Inställningar väljer du fliken Testning.
Välj weblogic-café.
I panelen Inställningar för weblogic-café väljer du fliken Testning.
+ Expandera ikonen bredvid weblogic-café. Skärmen bör se ut ungefär som i följande exempel. I synnerhet bör du se värden som liknar http://sample-domain1-managed-server1:8001/weblogic-cafe/index.xhtml i kolumnen Testpunkt .

Kommentar

Hyperlänkarna i kolumnen Testpunkt kan inte väljas eftersom vi inte konfigurerade administratörskonsolen med den externa URL som den körs på. Den här artikeln visar WLS-administratörskonsolen bara som en demonstration. Använd inte WLS-administratörskonsolen för några varaktiga konfigurationsändringar när du kör WLS på AKS. Den molnbaserade designen av WLS på AKS kräver att alla varaktiga konfigurationer måste representeras i de första docker-avbildningarna eller tillämpas på aks-klustret som körs med hjälp av CI/CD-tekniker, till exempel uppdatering av modellen, enligt beskrivningen i Oracle-dokumentationen.
Förstå värdet för context-path exempelappen som du distribuerade. Om du har distribuerat den rekommenderade exempelappen är den context-pathweblogic-cafe.
Skapa en fullständigt kvalificerad URL för exempelappen genom att lägga context-path till värdet till clusterExternalUrl . Om du har distribuerat den rekommenderade exempelappen bör den fullständigt kvalificerade URL:en vara ungefär som http://wlsgw202401-wls-aks-domain1.eastus.cloudapp.azure.com/weblogic-cafe/.
Klistra in den fullständigt kvalificerade URL:en i en Internetansluten webbläsare. Om du har distribuerat den rekommenderade exempelappen bör du se resultat som liknar följande skärmbild:

Rensa resurser

För att undvika Azure-avgifter bör du rensa onödiga resurser. När du inte längre behöver klustret använder du kommandot az group delete . Följande kommando tar bort resursgruppen, containertjänsten, containerregistret och alla relaterade resurser:

az group delete --name <resource-group-name> --yes --no-wait
az group delete --name <db-resource-group-name> --yes --no-wait

Nästa steg

Läs mer om att köra WLS på AKS eller virtuella datorer genom att följa dessa länkar:

WLS på AKS

Migrera WebLogic Server-program till Azure Kubernetes Service

WLS på virtuella datorer

Dela via