Implantar um aplicativo Java com o WebLogic Server em um cluster do Serviço Kubernetes do Azure (AKS)

Artigo
02/14/2024

Este artigo demonstra como:

Execute seu Java, Java EE ou Jakarta EE no Oracle WebLogic Server (WLS).
Levante um cluster WLS usando a oferta do Azure Marketplace.
Crie a imagem do Docker do aplicativo para servir como imagem auxiliar para fornecer modelos e aplicativos do WebLogic Deploy Tooling (WDT).
Implante o aplicativo em contêiner no cluster WLS existente no AKS com conexão ao Microsoft Azure SQL.

Este artigo usa a oferta do Azure Marketplace para WLS para acelerar sua jornada para o AKS. A oferta provisiona automaticamente vários recursos do Azure, incluindo os seguintes recursos:

Uma instância do Registro de Contêiner do Azure
Um cluster AKS
Uma instância AGIC (Azure App Gateway Ingress Controller)
O operador WebLogic
Uma imagem de contêiner, incluindo o tempo de execução do WebLogic
Um cluster WLS sem um aplicativo

Em seguida, este artigo apresenta a criação de uma imagem auxiliar passo a passo para atualizar um cluster WLS existente. A imagem auxiliar fornece modelos de aplicação e WDT.

Para automação total, você pode selecionar seu aplicativo e configurar a conexão da fonte de dados do portal do Azure antes da implantação da oferta. Para ver a oferta, visite o portal do Azure.

Para obter orientação passo a passo sobre como configurar o WebLogic Server no Serviço Kubernetes do Azure, consulte a documentação oficial da Oracle no Serviço Kubernetes do Azure.

Pré-requisitos

Se não tiver uma subscrição do Azure, crie uma conta gratuita do Azure antes de começar.
Verifique se a identidade do Azure que você usa para entrar e concluir este artigo tem a função Proprietário na assinatura atual ou as funções de Colaborador e Administrador de Acesso de Usuário na assinatura atual. Para obter uma visão geral das funções do Azure, consulte O que é o controle de acesso baseado em função do Azure (Azure RBAC)? Para obter detalhes sobre as funções específicas exigidas pelo WLS no AKS, consulte Funções internas do Azure.
Ter as credenciais para uma conta de logon único (SSO) Oracle. Para criar uma, consulte Criar sua conta Oracle.
Aceite os termos de licença para WLS.
- Visite o Oracle Container Registry e faça login.
- Se você tiver um direito de suporte, selecione Middleware e, em seguida, pesquise e selecione weblogic_cpu.
- Se você não tiver um direito de suporte da Oracle, selecione Middleware e, em seguida, pesquise e selecione weblogic.
  
  Nota
  
  Obtenha um direito de suporte da Oracle antes de entrar em produção. A falha em fazer isso resulta na execução de imagens inseguras que não são corrigidas para falhas críticas de segurança. Para obter mais informações sobre as atualizações críticas de patches da Oracle, consulte Atualizações críticas de patches, alertas de segurança e boletins da Oracle.
- Aceite o contrato de licença.
Prepare uma máquina local com o sistema operacional Unix-like instalado (por exemplo, Ubuntu, Azure Linux, macOS, Windows Subsystem for Linux).
- CLI do Azure. Use az --version para testar se az funciona. Este documento foi testado com a versão 2.55.1.
- Docker. Este documento foi testado com o Docker versão 20.10.7. Use docker info para testar se o Docker Daemon está em execução.
- Kubectl. Use kubectl version para testar se kubectl funciona. Este documento foi testado com a versão v1.21.2.
- Um Java JDK compatível com a versão do WLS que você pretende executar. O artigo orienta você a instalar uma versão do WLS que usa o JDK 11. O Azure recomenda o Microsoft Build do OpenJDK. Certifique-se de que sua JAVA_HOME variável de ambiente esteja definida corretamente nos shells nos quais você executa os comandos.
- Maven 3.5.0 ou superior.
- Certifique-se de ter o utilitário zip/unzip instalado. Use zip/unzip -v para testar se zip/unzip funciona.
Todas as etapas neste artigo, exceto aquelas que envolvem o Docker, também podem ser executadas no Azure Cloud Shell. Para saber mais sobre o Azure Cloud Shell, consulte O que é o Azure Cloud Shell?

Implantar WLS no AKS

As etapas nesta seção direcionam você a implantar o WLS no AKS da maneira mais simples possível. O WLS no AKS oferece uma seleção ampla e profunda de integrações do Azure. Para obter mais informações, consulte Quais são as soluções para executar o Oracle WebLogic Server no Serviço Kubernetes do Azure?

As etapas a seguir mostram como encontrar a oferta WLS no AKS e preencher o painel Noções básicas .

Na barra de pesquisa na parte superior do portal do Azure, insira weblogic. Nos resultados de pesquisa sugeridos automaticamente, na seção Marketplace, selecione WebLogic Server no AKS.

Você também pode ir diretamente para a oferta WebLogic Server on AKS .
Na página da oferta, selecione Criar.
No painel Noções básicas, verifique se o valor mostrado no campo Assinatura é o mesmo em que você fez logon no Azure. Verifique se você tem as funções listadas na seção de pré-requisitos.
Você deve implantar a oferta em um grupo de recursos vazio. No campo Grupo de recursos, selecione Criar novo e preencha um valor para o grupo de recursos. Como os grupos de recursos devem ser exclusivos dentro de uma assinatura, escolha um nome exclusivo. Uma maneira fácil de ter nomes exclusivos é usar uma combinação de suas iniciais, a data de hoje e algum identificador - por exemplo, ejb0723wls.
Em Detalhes da instância, selecione a região para a implantação. Para obter uma lista de regiões do Azure onde o AKS está disponível, consulte Disponibilidade da região do AKS.
Em Credenciais para WebLogic, deixe o valor padrão para Nome de usuário para WebLogic Administrator.
Preencha wlsAksCluster2022 a senha para o administrador WebLogic. Use o mesmo valor para os campos de confirmação e Senha para criptografia do Modelo WebLogic.
Role até a parte inferior do painel Noções básicas e observe os links úteis para documentação, suporte da comunidade e como relatar problemas.
Selecione Seguinte.

As etapas a seguir mostram como iniciar o processo de implantação.

Role até a seção Fornecer uma conta Oracle Single Sign-On (SSO). Preencha suas credenciais Oracle SSO a partir das pré-condições.
Siga as etapas na caixa de informações, começando com Antes de avançar, você deve aceitar os Termos e Restrições Padrão da Oracle.
Dependendo se a conta Oracle SSO tem ou não um direito de suporte Oracle, selecione a opção apropriada para Select the type of WebLogic Server Images.. Se a conta tiver um direito de suporte, selecione Imagens do WebLogic Server com patch. Caso contrário, selecione General WebLogic Server Images.
Deixe o valor em Select desired combination of WebLogic Server... em seu valor padrão. Você tem uma ampla gama de opções para as versões WLS, JDK e SO.
Na seção Aplicativo, ao lado de Implantar um aplicativo?, selecione Não.

As etapas a seguir fazem com que o console de administração do WLS e o aplicativo de exemplo sejam expostos à Internet pública com um complemento de entrada do Application Gateway interno. Para obter mais informações, consulte O que é o Application Gateway Ingress Controller?

Selecione Avançar para ver o painel TLS/SSL .
Selecione Avançar para ver o painel Balanceamento de carga.
Ao lado de Opções de balanceamento de carga, selecione Application Gateway Ingress Controller.
No Application Gateway Ingress Controller, você verá todos os campos pré-preenchidos com os padrões para Rede virtual e Sub-rede. Deixe os valores padrão.
Para Criar ingresso para o Console de Administração, selecione Sim.
Deixe os valores padrão para outros campos.
Selecione Rever + criar. Certifique-se de que a validação não falha. Se falhar, corrija quaisquer problemas de validação e, em seguida, selecione Rever + criar novamente.
Selecione Criar.
Acompanhe o progresso da implantação na página Implantação está em andamento .

Dependendo das condições da rede e de outras atividades na região selecionada, a implantação pode levar até 50 minutos para ser concluída.

Você pode executar as etapas na seção Criar um Banco de Dados SQL do Azure enquanto espera. Retorne a esta seção quando terminar de criar o banco de dados.

Examinar a saída da implantação

Use as etapas nesta seção para verificar se a implantação foi bem-sucedida.

Se você navegou para fora da página Implantação está em andamento , as etapas a seguir mostram como voltar a essa página. Se você ainda estiver na página que mostra Sua implantação foi concluída, pule para a etapa 5 após a próxima captura de tela.

No canto de qualquer página do portal do Azure, selecione o menu hambúrguer e selecione Grupos de recursos.
Na caixa com o texto Filtro para qualquer campo, insira os primeiros caracteres do grupo de recursos criado anteriormente. Se você seguiu a convenção recomendada, insira suas iniciais e selecione o grupo de recursos apropriado.
No painel de navegação, na seção Configurações , selecione Implantações. Você verá uma lista ordenada das implantações para esse grupo de recursos, com a mais recente primeiro.
Desloque-se para a entrada mais antiga desta lista. Esta entrada corresponde à implantação iniciada na seção anterior. Selecione a implantação mais antiga, conforme mostrado na captura de tela a seguir.
No painel de navegação, selecione Saídas. Esta lista mostra os valores de saída da implantação. Informações úteis estão incluídas nos resultados.
O valor adminConsoleExternalUrl é o link público e totalmente qualificado visível da Internet para o console de administração WLS para este cluster AKS. Selecione o ícone de cópia ao lado do valor do campo para copiar o link para a área de transferência. Guarde este valor para mais tarde.
O valor clusterExternalUrl é o link público e totalmente qualificado visível da Internet para o aplicativo de exemplo implantado no WLS neste cluster AKS. Selecione o ícone de cópia ao lado do valor do campo para copiar o link para a área de transferência. Guarde este valor para mais tarde.
O valor shellCmdtoOutputWlsImageModelYaml é a cadeia de caracteres base64 do modelo WDT que foi criada na imagem do contêiner. Guarde este valor para mais tarde.
O valor shellCmdtoOutputWlsImageProperties é a cadeia de caracteres base64 das propriedades do modelo WDT que foram incorporadas na imagem do contêiner. Guarde este valor para mais tarde.
O valor shellCmdtoConnectAks é o comando da CLI do Azure para se conectar a esse cluster AKS específico. Isso permite que você use kubectl para administrar o cluster.

Os outros valores nas saídas estão além do escopo deste artigo, mas são explicados em detalhes no guia do usuário do WebLogic on AKS.

Criar uma Base de Dados SQL do Azure

Para criar um banco de dados único do Banco de Dados SQL do Azure para uso com seu aplicativo, siga as etapas em Guia de início rápido: criar um único banco de dados no Banco de Dados SQL do Azure. Observe cuidadosamente as seguintes diferenças:

Na etapa Noções básicas, anote os valores para Grupo de recursos, Nome do banco de dados,< Nome> do servidor.database.windows.net, Login de administrador do servidor e Senha. Este artigo refere-se ao valor do grupo de recursos do banco de dados como <db-resource-group>.
Na etapa Rede, defina Método de conectividade como Ponto de extremidade Público, defina Permitir que os serviços e recursos do Azure acessem este servidor como Sim e defina Adicionar endereço IP do cliente atual como Sim.

Nota

A camada de computação sem servidor selecionada para esse banco de dados economiza dinheiro ao colocar o banco de dados em repouso durante os períodos de inatividade. O aplicativo de exemplo falhará se o banco de dados estiver suspenso quando o aplicativo for iniciado.

Para forçar a ativação do banco de dados, você pode executar uma consulta usando o editor de consultas. Siga as etapas em Consultar o banco de dados. Aqui está um exemplo de consulta: SELECT * FROM COFFEE;.

Crie um esquema para o aplicativo de exemplo. Siga Consultar o banco de dados para abrir o painel Editor de consultas . Introduza e execute a seguinte consulta:
```
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);
```
Após uma execução bem-sucedida, você verá a mensagem Consulta bem-sucedida: Linhas afetadas: 0. Se não vir esta mensagem, resolva o problema antes de continuar.

O banco de dados, tabelas, cluster AKS e cluster WLS são criados. Se desejar, você pode explorar o console de administração abrindo um navegador e navegando até o endereço de adminConsoleExternalUrl. Inicie sessão com os valores que introduziu durante a implementação do WLS no AKS.

Você pode continuar a preparar o AKS para hospedar seu aplicativo WebLogic.

Configurar e implantar o aplicativo de exemplo

A oferta provisiona o cluster WLS via modelo em imagem. Atualmente, o cluster WLS não tem nenhum aplicativo implantado.

Esta seção atualiza o cluster WLS implantando um aplicativo de exemplo usando imagem auxiliar.

Confira o aplicativo

Nesta seção, você clona o código de exemplo para este guia. O exemplo está no GitHub no repositório weblogic-on-azure na pasta javaee/weblogic-café/ . Aqui está a estrutura de arquivos do aplicativo.

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

Use os seguintes comandos para clonar o repositório:

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

Se vir uma mensagem sobre estar no estado "HEAD desanexado", é seguro ignorá-la. Isso significa apenas que você fez check-out de uma tag.

Use o seguinte comando para construir javaee/weblogic-café/:

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

O pacote deve ser gerado com êxito e localizado em $BASE_DIR/weblogic-on-azure/javaee/weblogic-café/target/weblogic-café.war. Se não vir o pacote, tem de resolver o problema antes de continuar.

Usar o Docker para criar uma imagem auxiliar

As etapas nesta seção mostram como criar uma imagem auxiliar. Esta imagem inclui os seguintes componentes:

O modelo em arquivos de modelo de imagem
A aplicação
O arquivo de arquivo do driver JDBC
A instalação do WebLogic Deploy Tooling

Uma imagem auxiliar é uma imagem de contêiner do Docker que contém seu aplicativo e configuração. O Operador WebLogic Kubernetes combina sua imagem auxiliar com a domain.spec.image no cluster AKS que contém o WebLogic Server, JDK e sistema operacional. Para obter mais informações sobre imagens auxiliares, consulte Imagens auxiliares na documentação do Oracle.

Esta seção requer um terminal Linux com a CLI do Azure e o kubectl instalados.

Use as seguintes etapas para criar a imagem:

Use os seguintes comandos para criar um diretório para preparar os modelos e o aplicativo:
```
mkdir -p ${BASE_DIR}/mystaging/models
cd ${BASE_DIR}/mystaging/models
```

Copie o valor shellCmdtoOutputWlsImageModelYaml que você salvou das saídas de implantação, cole-o na janela Bash e execute o comando. O comando deve ser semelhante ao exemplo a seguir:

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

Este comando produz um arquivo ${BASE_DIR}/mystaging/models/model.yaml com conteúdo semelhante ao exemplo a seguir:

# 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"

Da mesma forma, copie o valor shellCmdtoOutputWlsImageProperties , cole-o na janela Bash e execute o comando. O comando deve ser semelhante ao exemplo a seguir:

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

Este comando produz um arquivo ${BASE_DIR}/mystaging/models/model.properties com conteúdo semelhante ao exemplo a seguir:

# 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

Use as etapas a seguir para criar o arquivo de modelo de aplicativo.

Use os seguintes comandos para copiar weblogic-café.war e salvá-lo em 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

Use os comandos a seguir para criar o arquivo de modelo de aplicativo com o conteúdo mostrado. Salve o arquivo de modelo em ${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

Use os seguintes comandos para baixar e instalar o driver JDBC do Microsoft SQL Server para 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

Em seguida, use os comandos a seguir para criar o arquivo de modelo de conexão de banco de dados com o conteúdo mostrado. Salve o arquivo de modelo em ${BASE_DIR}/mystaging/models/dbmodel.yaml. O modelo usa espaços reservados (secretos sqlserver-secret) para nome de usuário, senha e URL do banco de dados. Verifique se os campos a seguir estão definidos corretamente. O modelo a seguir nomeia o recurso com jdbc/WebLogicCafeDB.

Nome do Item	Campo	Value
Nome JNDI	`resources.JDBCSystemResource.<resource-name>.JdbcResource.JDBCDataSourceParams.JNDIName`	`jdbc/WebLogicCafeDB`
Nome do driver	`resources.JDBCSystemResource.<resource-name>.JDBCDriverParams.DriverName`	`com.microsoft.sqlserver.jdbc.SQLServerDriver`
URL do banco de dados	`resources.JDBCSystemResource.<resource-name>.JDBCDriverParams.URL`	`@@SECRET:sqlserver-secret:url@@`
Palavra-passe da base de dados	`resources.JDBCSystemResource.<resource-name>.JDBCDriverParams.PasswordEncrypted`	`@@SECRET:sqlserver-secret:password@@`
Nome de usuário do banco de dados	`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

Use os seguintes comandos para criar um arquivo de arquivo de aplicativo e, em seguida, remova a pasta wlsdeploy , que você não precisa mais:
```
cd ${BASE_DIR}/mystaging/models
zip -r archive.zip wlsdeploy

rm -f -r wlsdeploy
```

Use os seguintes comandos para baixar e instalar o WebLogic Deploy Tooling (WDT) no diretório de preparo e remover seus arquivos weblogic-deploy/bin/*.cmd , que não são usados em ambientes UNIX:

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

Use o seguinte comando para remover o instalador do WDT:
```
rm weblogic-deploy.zip
```

Use os seguintes comandos para criar uma imagem auxiliar usando o 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

Execute o docker buildx build comando usando ${BASE_DIR}/mystaging/Dockerfile, conforme mostrado no exemplo a seguir:

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

Quando você cria a imagem com êxito, a saída é semelhante ao exemplo a seguir:

[+] 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

Se você criou a imagem com êxito, ela deve estar agora no repositório Docker da sua máquina local. Você pode verificar a criação da imagem usando o seguinte comando:
```
docker images model-in-image:WLS-v1
```
Este comando deve produzir uma saída semelhante ao exemplo a seguir:
```
REPOSITORY       TAG       IMAGE ID       CREATED       SIZE
model-in-image   WLS-v1    76abc1afdcc6   2 hours ago   8.61MB
```
Depois que a imagem é criada, ela deve ter os executáveis WDT em /auxiliary/weblogic-deploy, e arquivos de modelo, propriedade e arquivo WDT em /auxiliary/models. Use o seguinte comando na imagem do Docker para verificar esse resultado:
```
docker run -it --rm model-in-image:WLS-v1 find /auxiliary -maxdepth 2 -type f -print
```
Este comando deve produzir uma saída semelhante ao exemplo a seguir:
```
/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
```
Use as seguintes etapas para enviar a imagem auxiliar para o Registro de Contêiner do Azure:
1. Abra o portal do Azure e vá para o grupo de recursos que você provisionou na seção Implantar WSL no AKS .
2. Selecione o recurso do tipo Registro de contêiner na lista de recursos.
3. Passe o mouse sobre o valor ao lado de Servidor de login e selecione o ícone de cópia ao lado do texto.
4. Salve o ACR_LOGIN_SERVER valor na variável de ambiente usando o seguinte comando:
```
export ACR_LOGIN_SERVER=<value-from-clipboard>
```
5. Execute os seguintes comandos para marcar e enviar a imagem por push. Verifique se o Docker está em execução antes de executar esses comandos.
```
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. Você pode executar az acr repository show para testar se a imagem é enviada por push para o repositório remoto com êxito, conforme mostrado no exemplo a seguir:
```
az acr repository show --name ${ACR_NAME} --image wlsaks-auxiliary-image:1.0
```
  Este comando deve produzir uma saída semelhante ao exemplo a seguir:
```
{
  "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
}
```

Aplicar a imagem auxiliar

Nas etapas anteriores, você criou a imagem auxiliar, incluindo modelos e WDT. Antes de aplicar a imagem auxiliar ao cluster WLS, use as etapas a seguir para criar o segredo para a URL da fonte de dados, nome de usuário e senha. O segredo é usado como parte do espaço reservado no dbmodel.yaml.

Conecte-se ao cluster AKS copiando o valor shellCmdtoConnectAks que você salvou anteriormente, colando-o na janela Bash e executando o comando. O comando deve ser semelhante ao exemplo a seguir:
```
az account set --subscription <subscription>; 
az aks get-credentials \
    --resource-group <resource-group> \
    --name <name>
```
Você deve ver uma saída semelhante ao exemplo a seguir. Se você não vir essa saída, solucione e resolva o problema antes de continuar.
```
Merged "<name>" as current context in /Users/<username>/.kube/config
```

Use as etapas a seguir para obter valores para as variáveis mostradas na tabela a seguir. Use esses valores posteriormente para criar o segredo para a conexão da fonte de dados.

Variável	Description	Exemplo
`DB_CONNECTION_STRING`	A cadeia de conexão do SQL Server.	`jdbc:sqlserver://sqlserverforwlsaks.database.windows.net:1433;database=wlsaksquickstart0125`
`DB_USER`	O nome de usuário para entrar no servidor SQL.	`welogic@sqlserverforwlsaks`
`DB_PASSWORD`	A senha para entrar no servidor sQL.	`Secret123456`

Visite o recurso de banco de dados SQL no portal do Azure.
No painel de navegação, em Configurações, selecione Cadeias de conexão.
Selecione a guia JDBC .
Selecione o ícone de cópia para copiar a cadeia de conexão para a área de transferência.
Para DB_CONNECTION_STRING, use toda a cadeia de conexão, mas substitua o espaço reservado {your_password_here} pela senha do banco de dados.
Para DB_USER, use a parte da cadeia de conexão de azureuser até mas não incluindo ;password={your_password_here}.
Para DB_PASSWORD, use o valor que você inseriu quando criou o banco de dados.

Use os comandos a seguir para criar o Segredo do Kubernetes. Este artigo usa o nome sqlserver-secret secreto para o segredo da conexão da fonte de dados. Se você usar um nome diferente, verifique se o valor é o mesmo que o de dbmodel.yaml.

Nos comandos a seguir, certifique-se de definir as variáveis DB_CONNECTION_STRING, DB_USERe DB_PASSWORD corretamente substituindo os exemplos de espaço reservado pelos valores descritos nas etapas anteriores. Certifique-se de colocar o DB_ valor das variáveis entre aspas simples para evitar que o shell interfira com os valores.

export DB_CONNECTION_STRING='<example-jdbc:sqlserver://sqlserverforwlsaks.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}

Você deve ver a seguinte saída antes de continuar. Se você não vir essa saída, solucione e resolva o problema antes de continuar.

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

Aplique a imagem auxiliar corrigindo a definição de recurso personalizado (CRD) do domínio usando o kubectl patch comando.

A imagem auxiliar é definida em spec.configuration.model.auxiliaryImages, como mostrado no exemplo a seguir. Para obter mais informações, consulte imagens auxiliares.

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

Use os seguintes comandos para aumentar o restartVersion valor e use kubectl patch para aplicar a imagem auxiliar ao domínio CRD usando a definição mostrada:

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

Aguarde até que o servidor de administração e os servidores gerenciados mostrem os valores no seguinte bloco de saída antes de continuar:
```
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
```
Pode levar de 5 a 10 minutos para que o sistema atinja esse estado. A lista a seguir fornece uma visão geral do que está acontecendo enquanto você espera:
- Você deve ver a sample-domain1-introspector execução primeiro. Este software procura alterações no recurso personalizado de domínio para que possa executar as ações necessárias no cluster Kubernetes.
- Quando as alterações são detetadas, o introspector de domínio mata e inicia novos pods para implementar as alterações.
- Em seguida, você deve ver o sample-domain1-admin-server pod terminar e reiniciar.
- Em seguida, você verá os dois servidores gerenciados serem encerrados e reiniciados.
- Só quando os três pods mostrarem o 1/1 Running estado, é ok prosseguir.

Verificar a funcionalidade da implantação

Use as seguintes etapas para verificar a funcionalidade da implantação exibindo o console de administração do WLS e o aplicativo de exemplo:

Cole o valor adminConsoleExternalUrl na barra de endereços de um navegador da Web conectado à Internet. Você deve ver a tela de login do console de administração WLS familiar.
Entre com o nome weblogic de usuário e a senha que você inseriu ao implantar o WLS a partir do portal do Azure. Lembre-se que este valor é wlsAksCluster2022.
Na caixa Estrutura do Domínio, selecione Serviços.
Em Serviços, selecione Fontes de Dados.
No painel Resumo das fontes de dados JDBC, selecione Monitoramento. Sua tela deve ser semelhante ao exemplo a seguir. Você acha que o estado da fonte de dados está sendo executado em servidores gerenciados.
Na caixa Estrutura do Domínio, selecione Implantações.
Na tabela Implantações, deve haver uma linha. O nome deve ser o mesmo valor que o Application valor no arquivo appmodel.yaml . Selecione o nome.
No painel Configurações, selecione a guia Teste.
Selecione weblogic-café.
No painel Configurações para weblogic-café , selecione a guia Teste .
Expanda o + ícone ao lado de weblogic-café. Sua tela deve ser semelhante ao exemplo a seguir. Em particular, você deve ver valores semelhantes aos http://sample-domain1-managed-server1:8001/weblogic-cafe/index.xhtml na coluna Ponto de teste .

Nota

Os hiperlinks na coluna Ponto de Teste não podem ser selecionados porque não configuramos o console de administração com a URL externa na qual ele está sendo executado. Este artigo mostra o console de administração do WLS apenas como demonstração. Não use o console de administração do WLS para alterações de configuração duráveis ao executar o WLS no AKS. O design nativo da nuvem do WLS no AKS requer que qualquer configuração durável seja representada nas imagens iniciais do docker ou aplicada ao cluster AKS em execução usando técnicas de CI/CD, como a atualização do modelo, conforme descrito na documentação do Oracle.
Entenda o context-path valor do aplicativo de exemplo que você implantou. Se você implantou o aplicativo de exemplo recomendado, o context-path é weblogic-cafe.
Construa uma URL totalmente qualificada para o aplicativo de exemplo anexando o context-path valor clusterExternalUrl. Se você implantou o aplicativo de exemplo recomendado, a URL totalmente qualificada deve ser algo como http://wlsgw202401-wls-aks-domain1.eastus.cloudapp.azure.com/weblogic-cafe/.
Cole o URL totalmente qualificado em um navegador da Web conectado à Internet. Se você implantou o aplicativo de exemplo recomendado, deverá ver resultados semelhantes à captura de tela a seguir:

Clean up resources (Limpar recursos)

Para evitar cobranças do Azure, você deve limpar recursos desnecessários. Quando não precisar mais do cluster, use o comando az group delete . O comando a seguir remove o grupo de recursos, o serviço de contêiner, o registro de contêiner e todos os recursos relacionados:

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

Próximos passos

Saiba mais sobre como executar WLS em AKS ou máquinas virtuais seguindo estes links:

WLS no AKS

Migrar aplicativos do WebLogic Server para o Serviço Kubernetes do Azure

WLS em máquinas virtuais

Share via