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

Artigo
08/02/2024

Este artigo demonstra como:

Execute seu aplicativo Java no Oracle WebLogic Server (WLS).
Configure um cluster do WebLogic Server no AKS usando uma oferta do Azure Marketplace.
Compile uma imagem do Docker de aplicativo que inclua modelos do WebLogic Deploy Tooling (WDT).
Implante o aplicativo conteinerizado no cluster do WebLogic Server no AKS com conexão ao SQL do Microsoft Azure.

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

Uma instância do Registro de Contêiner do Azure
Um cluster do AKS
Uma instância do AGIC (Controlador de Entrada do Gateway de Aplicativo do Azure)
O WebLogic Operator
Uma imagem de contêiner, incluindo o runtime do WebLogic
Um cluster do WebLogic Server sem um aplicativo

Depois, o artigo mostra como compilar uma imagem para atualizar o cluster do WebLogic Server. A imagem fornece o aplicativo e os modelos WDT.

Se você prefere um método menos automatizado para implantar o WebLogic no AKS, confira o guia detalhado na documentação oficial da Oracle para Serviço de Kubernetes do Azure.

Se você estiver interessado em fornecer comentários ou trabalhar em estreita colaboração em seus cenários de migração com a equipe de engenharia que desenvolve soluções WebLogic do AKS, preencha esta breve pesquisa sobre migração WebLogic e inclua suas informações de contato. A equipe de gerentes de programa, arquitetos e engenheiros entrará em contato prontamente com você para iniciar uma estreita colaboração.

Pré-requisitos

Caso você não tenha uma assinatura 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 Colaborador e Administrador de Acesso do Usuário na assinatura atual. Para obter uma visão geral das funções do Azure, consulte O que é o RBAC (controle de acesso baseado em função) do Azure? Para obter detalhes sobre as funções específicas exigidas pelo WLS no AKS, consulte Funções internas do Azure.
Tenha as credenciais para uma conta de SSO (logon único) da Oracle. Para criar uma, consulte Criar conta Oracle.
Aceitar os termos de licença do WebLogic Server.
- Acesse o Registro de Contêiner Oracle e entre.
- 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.
- Aceite o contrato de licença.
Observação

Obtenha um direito de suporte da Oracle antes de ir para a produção. Não fazer isso resulta na execução de imagens inseguras que não são corrigidas por falhas críticas de segurança. Para obter mais informações sobre as atualizações críticas de patch da Oracle, consulte Atualizações críticas de patch, Boletins e Alertas de segurança da Oracle.
Prepare um computador local com o sistema operacional semelhante ao Unix instalado, como Ubuntu, Azure Linux, macOS, Subsistema do Windows para Linux.
- CLI do Azure. Use az --version para testar se o 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 daemon do Docker está em execução.
- kubectl. Use kubectl version para testar se o kubectl funciona. Este documento foi testado com a versão v1.21.2.
- Um Java Development Kit (JDK) compatível com a versão do WebLogic Server que você pretende executar. O artigo orienta você a instalar uma versão do WebLogic Server que usa o JDK 11. Verifique se a variável de ambiente JAVA_HOME está definida corretamente nos shells em que você executa os comandos.
- Maven 3.5.0 ou superior.
- Verifique se você tem o utilitário de compactação/descompactação instalado. Use zip/unzip -v para testar se zip/unzip funciona.
Observação

Você pode realizar todas as etapas deste artigo no Azure Cloud Shell, exceto as que envolvem o Docker. Para saber mais sobre o Azure Cloud Shell, confira O que é o Azure Cloud Shell?

Implantar o WebLogic Server no AKS

As etapas a seguir mostram como encontrar a oferta do WebLogic Server 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 da pesquisa sugeridos automaticamente, na seção Marketplace, selecione WebLogic Server no AKS.

Você também pode ir diretamente para a oferta WebLogic Server no AKS.
Na página da oferta, selecione Criar.
No painel Informações básicas, verifique se o valor mostrado no campo Assinatura é o mesmo que você usou para entrar no Azure. Verifique se você tem as funções listadas na seção de pré-requisitos para a assinatura.
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 em uma assinatura, escolha um nome exclusivo. Uma forma 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 das regiões do Azure em que o AKS está disponível, consulte Disponibilidade da região do AKS.
Em Credenciais para WebLogic, deixe o valor padrão do Nome de usuário para o Administrador do WebLogic.
Preencha wlsAksCluster2022 na Senha de Administrador do WebLogic. Use o mesmo valor para os campos de confirmação e Criptografia de senha para o modelo do WebLogic.
Selecione Avançar.

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

Role até a seção rotulada Fornecer uma conta de SSO (logon único) da Oracle. Preencha as credenciais de SSO da Oracle de acordo com as pré-condições.
Anote as etapas da caixa de informações começando com Antes de avançar, você precisa aceitar os Termos e Restrições Padrão da Oracle.
Dependendo se a conta de SSO da Oracle tem ou não um direito de suporte da Oracle, escolha a opção apropriada em Selecionar o tipo de Imagens do WebLogic Server. Se a conta tiver um direito de suporte, selecione Imagens Corrigidas do WebLogic Server. Caso contrário, selecione Imagens Gerais do WebLogic Server.
Mantenha o valor indicado em Selecionar combinação desejada do WebLogic Server… com o valor padrão. Você tem uma ampla gama de opções para o WebLogic Server, o JDK e a versão do sistema operacional.
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 WebLogic Server e o aplicativo de amostra sejam expostos à Internet pública com um complemento de entrada do Gateway de Aplicativo interno. Para obter mais informações, confira O que é o Controlador de Entrada do Gateway de Aplicativo?

Selecione Avançar para ver o painel TLS/SSL.
Escolha Avançar para ver o painel Balanceamento de carga.
Ao lado de Opções de Balanceamento de Carga, selecione o Controlador de Entrada do Gateway de Aplicativo.
Em Controlador de Entrada do Gateway de Aplicativo, você verá todos os campos preenchidos previamente com os padrões em Rede virtual e Sub-rede. Mantenha os valores padrão.
Em Criar entrada para o Console de Administração, selecione Sim.
Mantenha os valores padrão para os outros campos.
Selecione Examinar + criar. Verifique se a validação dá certo. Em caso de erro, corrija os problemas de validação e selecione Revisar + criar novamente.
Selecione Criar.
Acompanhe o progresso da implantação na página Implantação 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 realizar as etapas da seção Criar um banco de dados SQL do Azure enquanto aguarda. Volte a esta seção quando terminar de criar o banco de dados.

Analisar a saída da implantação

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

Se você saiu da página A implantação está em andamento, as etapas a seguir mostram como voltar para ela. Se você ainda estiver na página que mostra A implantação foi concluída, vá 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 de hambúrguer e escolha Grupos de recursos.
Na caixa com o texto Filtrar 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, escolha Implantações. Você verá uma lista ordenada das implantações nesse grupo de recursos, com a mais recente primeiro.
Role até a entrada mais antiga nesta lista. Essa 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. Essa lista mostra os valores de saída da implantação. Informações úteis são incluídas nas saídas.
O valor adminConsoleExternalUrl é o link totalmente qualificado e visível na Internet pública para o console de administração do WebLogic Server desse cluster do AKS. Selecione o ícone Copiar ao lado do valor do campo para copiar o link para a área de transferência. Salve esse valor para mais tarde.
O valor clusterExternalUrl é o link público e totalmente qualificado visível na Internet para o aplicativo de amostra implantado no WebLogic Server neste cluster do AKS. Selecione o ícone Copiar ao lado do valor do campo para copiar o link para a área de transferência. Salve esse valor para mais tarde.
O valor de shellCmdtoOutputWlsImageModelYaml é a cadeia de caracteres base64 do modelo do WDT que é usada para compilar a imagem de contêiner. Salve esse valor para mais tarde.
O valor de shellCmdtoOutputWlsImageProperties é a cadeia de caracteres base64 das propriedades do modelo do WDT que é usada para compilar a imagem de contêiner. Salve esse valor para mais tarde.
O valor de shellCmdtoConnectAks é o comando da CLI do Azure para se conectar a esse cluster específico do AKS.

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

Criar um Banco de Dados SQL do Azure

Para criar um banco de dados individual do Banco de Dados SQL do Azure para uso com seu aplicativo, siga as etapas em Início Rápido: Criar um banco de dados individual no Banco de Dados SQL do Azure. Observe cuidadosamente as seguintes diferenças:

Na etapa Básico, anote os valores de Grupo de recursos, Nome do banco de dados, <server-name>.database.windows.net, Logon de administrador do servidor e Senha. Este artigo se refere ao valor do Grupo de recursos do banco de dados como <db-resource-group>.
Na etapa Rede, defina o Método de conectividade como Ponto de extremidade público, defina Permitir que serviços e recursos do Azure acessem este servidor como Sim e defina Adicionar endereço IP do cliente atual como Sim.

Observação

A camada de computação sem servidor selecionada para este banco de dados economiza dinheiro colocando o banco de dados em suspensão durante períodos de inatividade. O aplicativo de amostra falhará se o banco de dados estiver dormindo 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á uma consulta de exemplo: SELECT * FROM COFFEE;.

Em seguida, crie um esquema para o aplicativo de exemplo seguindo estes passos:

Abra o painel Editor de Consultas seguindo as etapas na seção Consultar o banco de dados do Guia de Início Rápido: criar um banco de dados individual – Banco de Dados SQL do Azure.

Insira 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: 1. Se você não vir essa mensagem, resolva o problema antes de prosseguir.

O banco de dados, as tabelas, o cluster do AKS e o cluster do WebLogic Server foram criados. Se desejar, explore o console de administração abrindo um navegador e navegando até o endereço de adminConsoleExternalUrl. Entre com os valores que você inseriu durante a implantação do WebLogic Server no AKS.

Prossiga para preparar o AKS para hospedar seu aplicativo do WebLogic.

Configurar e implantar um aplicativo de exemplo

A oferta provisiona o cluster do WebLogic Server via modelo na imagem. Atualmente, o cluster do WebLogic Server não tem nenhum aplicativo implantado.

Esta seção atualiza o cluster do WebLogic Server implantando um aplicativo de amostra usando a imagem auxiliar.

Fazer check-out do aplicativo

Nesta seção, você clonará o código de exemplo deste guia. A amostra está no GitHub no repositório weblogic-on-azure na pasta javaee/weblogic-cafe/. Esta é 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 você vir uma mensagem sobre estar no estado "detached HEAD", essa mensagem pode ser ignorada com segurança. Isso apenas significa que você fez check-out de uma tag.

Use o seguinte comando para compilar javaee/weblogic-cafe/:

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

O pacote será gerado com êxito e estará localizado em $BASE_DIR/weblogic-on-azure/javaee/weblogic-cafe/target/weblogic-cafe.war. Se você não vir o pacote, resolva o problema antes de continuar.

Usar o Docker para criar uma imagem auxiliar

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

Os arquivos do modelo Modelo na Imagem
Seu aplicativo
O arquivo de driver Java Database Connectivity (JDBC)
A instalação do WebLogic Deploy Tooling

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

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

Use as seguintes etapas para compilar 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 de shellCmdtoOutputWlsImageModelYaml que você salvou das saídas de implantação, cole-o na janela do Bash e execute o comando. O resultado deve ser semelhante ao seguinte exemplo:

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

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

# 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 de shellCmdtoOutputWlsImageProperties, cole-o na janela do Bash e execute o comando. O resultado deve ser semelhante ao seguinte exemplo:

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

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

# 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-cafe.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 em 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 (segredo sqlserver-secret) para o nome de usuário do banco de dados, a senha e a URL. Verifique se os campos a seguir estão definidos corretamente. O modelo a seguir nomeia o recurso com jdbc/WebLogicCafeDB.

Nome do Item	Campo	Valor
Nome do 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@@`
Senha do banco 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 morto do aplicativo e, em seguida, remova a pasta wlsdeploy, da qual 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 WDT (WebLogic Deploy Tooling) no diretório de teste e remover os 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 comando docker buildx build usando ${BASE_DIR}/mystaging/Dockerfile, conforme mostrado no seguinte exemplo:

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 seguinte exemplo:

[+] 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 sucesso, ela estará no repositório Docker do seu computador. Verifique a criação da imagem usando o seguinte comando:
```
docker images model-in-image:WLS-v1
```
Esse comando produzirá uma saída semelhante ao seguinte exemplo:
```
REPOSITORY       TAG       IMAGE ID       CREATED       SIZE
model-in-image   WLS-v1    76abc1afdcc6   2 hours ago   8.61MB
```
Depois que a imagem for criada, ela terá os executáveis do WDT em /auxiliary/weblogic-deploy e os arquivos de modelo, propriedade e arquivo morto do WDT em /auxiliary/models. Use o seguinte comando para verificar o conteúdo da imagem:
```
docker run -it --rm model-in-image:WLS-v1 find /auxiliary -maxdepth 2 -type f -print
```
Esse comando produzirá uma saída semelhante ao seguinte exemplo:
```
/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 efetuar push da 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 WebLogic Server 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 do Servidor de logon e selecione o ícone de cópia ao lado do texto.
4. Salve o valor na variável de ambiente ACR_LOGIN_SERVER usando o seguinte comando:
```
export ACR_LOGIN_SERVER=<value-from-clipboard>
```
5. Execute os comandos a seguir para marcar a imagem e efetuar push dela. 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. Execute az acr repository show para testar se a imagem foi enviada por push para o repositório remoto com êxito, conforme mostrado no seguinte exemplo:
```
az acr repository show --name ${ACR_NAME} --image wlsaks-auxiliary-image:1.0
```
  Esse comando produzirá uma saída semelhante ao seguinte exemplo:
```
{
  "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 os modelos e o WDT. Antes de aplicar a imagem auxiliar ao cluster do WebLogic Server, use as etapas a seguir para criar o segredo para a URL do recurso de dados, o nome de usuário e a senha. O segredo é usado como parte do espaço reservado em dbmodel.yaml.

Conecte-se ao cluster do AKS copiando o valor de shellCmdtoConnectAks que você já salvou, colando-o na janela do Bash e executando o comando. O resultado deve ser semelhante ao seguinte exemplo:
```
az account set --subscription <subscription>; 
az aks get-credentials \
    --resource-group <resource-group> \
    --name <name>
```
Você deverá ver uma saída semelhante ao exemplo a seguir. Se você não vir essa saída, resolva o problema antes de prosseguir.
```
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. Você usará esses valores para criar o segredo para a conexão de fonte de dados.

Variável	Descrição	Exemplo
`DB_CONNECTION_STRING`	A cadeia de conexão do SQL Server.	`jdbc:sqlserver://server-name.database.windows.net:1433;database=wlsaksquickstart0125`
`DB_USER`	O nome de usuário a ser conectado ao SQL Server.	`welogic@sqlserverforwlsaks`
`DB_PASSWORD`	A senha usada para entrar no SQL Server.	`Secret123456`

Acesse 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.
Escolha o ícone Copiar 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 de segredo sqlserver-secret para o segredo da conexão de fonte de dados. Se você usar um nome diferente, verifique se o valor é o mesmo que o de dbmodel.yaml.

Nos comandos a seguir, defina as variáveis DB_CONNECTION_STRING, DB_USER e DB_PASSWORD corretamente, substituindo os exemplos de espaço reservado pelos valores descritos nas etapas anteriores. Para evitar interferência do shell, coloque o valor das variáveis DB_ entre aspas simples.

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}

Você verá a saída a seguir antes de continuar. Se você não vir essa saída, resolva o problema antes de prosseguir.

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

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

A imagem auxiliar é definida em spec.configuration.model.auxiliaryImages, conforme mostrado no exemplo a seguir.

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 valor de restartVersion e use kubectl patch para aplicar a imagem auxiliar à CRD do domínio 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

Antes de continuar, aguarde até que o servidor administrador e os servidores gerenciados mostrem os valores no seguinte bloco de saída:
```
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
```
O sistema pode levar de 5 a 10 minutos para chegar a esse estado. A seguinte lista apresenta uma visão geral do que acontece enquanto você aguarda:
- Você verá o sample-domain1-introspector ser executado primeiro. Esse software procura alterações no recurso personalizado do domínio para que ele possa executar as ações necessárias no cluster do Kubernetes.
- Quando são detectadas as alterações, o introspector de domínio encerra e inicia novos pods para distribuir as alterações.
- Em seguida, você verá o pod sample-domain1-admin-server ser encerrado e reiniciado.
- Depois, você verá os dois servidores gerenciados serem encerrados e reiniciados.
- Só prossiga quando os três pods mostrarem o estado 1/1 Running.

Verificar a funcionalidade da implantação

Use as etapas a seguir para verificar a funcionalidade da implantação, visualizando o console de administração do WebLogic Server e o aplicativo de amostra:

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

Observação

Os hiperlinks da coluna Ponto de Teste não são selecionáveis, porque não configuramos o console de administração com a URL externa na qual ele está em execução. Este artigo mostra o console de administração do WebLogic Server apenas a título de demonstração. Não use o console de administração do WebLogic Server para qualquer alteração de configuração duradoura ao executar o WebLogic Server no AKS. O design nativo da nuvem do WebLogic Server no AKS exige que qualquer configuração durável seja representada nas imagens iniciais do docker ou aplicada ao cluster do AKS em execução usando técnicas de CI/CD, como a atualização do modelo, conforme descrito na documentação da Oracle.
Entenda o valor de context-path do aplicativo de exemplo implantado. Se você implantou o aplicativo de exemplo recomendado, o context-path será weblogic-cafe.
Construa uma URL totalmente qualificada para o aplicativo de exemplo acrescentando context-path ao valor de 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 a URL totalmente qualificada em um navegador da Web conectado à Internet. Se você implantou o aplicativo de exemplo recomendado, verá resultados semelhantes à seguinte captura de tela:

Limpar os recursos

Para evitar cobranças do Azure, limpe recursos desnecessários. Quando você não precisar mais do cluster, use o comando az group delete. O seguinte comando remove o grupo de recursos, o serviço de contêiner, o registro de contêiner, banco de dados 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óximas etapas

Saiba mais sobre a execução do WebLogic Server no AKS ou em máquinas virtuais seguindo estes links:

Para obter mais informações sobre as ofertas do Oracle WebLogic no Azure Marketplace, consulte Oracle WebLogic Server no Azure. Essas ofertas são todas do tipo Traga sua própria licença. Eles pressupõem que você já tenha as licenças apropriadas com a Oracle e esteja devidamente licenciado para executar ofertas no Azure.

Compartilhar via