Usar Azure Pipelines para criar e implantar uma solução de HPC

As ferramentas do Azure DevOps podem automatizar a compilação e os testes de soluções do Lote do Azure para computação de alto desempenho (HPC). Azure Pipelines fornece processos modernos de integração contínua (CI) e implantação contínua (CD) para criar, implantar, testar e monitorar software. Esses processos aceleram a entrega de software, permitindo que você se concentre em seu código em vez de dar suporte à infraestrutura e às operações.

Este artigo mostra como configurar processos de CI/CD usando Azure Pipelines com modelos do ARM (modelos de Azure Resource Manager) para implantar soluções de HPC em Lote do Azure. O exemplo cria um pipeline de build e lançamento para implantar uma infraestrutura de Lote do Azure e lançar um pacote de aplicativos. O diagrama a seguir mostra o fluxo de implantação geral, supondo que o código seja desenvolvido localmente:

Diagrama mostrando o fluxo de implantação no pipeline.

Pré-requisitos

Para seguir as etapas deste artigo, você precisa:

Uma organização Azure DevOps e um projeto de Azure DevOps com um repositório Azure Repos criado na organização. Você deve ter as funções de Administrador de Projeto, Administrador de Build e Administrador de Release no projeto do Azure DevOps.
Uma assinatura ativa do Azure com a função Proprietário ou outra função que inclua permissões para atribuir funções. Para obter mais informações, consulte Entenda Azure atribuições de função.
Uma compreensão básica do controle do código-fonte e da sintaxe de modelo do ARM.

Preparar a solução

O exemplo neste artigo usa vários modelos do ARM e um aplicativo de processamento de vídeo de software livre existente, FFmpeg. Você pode copiar ou baixar esses recursos e enviá-los com push para o seu repositório do Azure Repos.

Importante

Este exemplo implanta software do Windows em nós em lote baseados no Windows. Azure Pipelines, modelos ARM e Batch também oferecem suporte completo a software e nós Linux.

Entender os modelos do ARM

Três modelos de funcionalidade, semelhantes a unidades ou módulos, implementam partes específicas da funcionalidade. Um modelo de solução de ponta a ponta implanta os modelos de funcionalidade subjacentes. Essa estrutura de modelo vinculada permite que cada modelo de funcionalidade seja testado individualmente e reutilizado entre soluções.

Diagrama mostrando uma estrutura de modelo vinculada usando modelos do ARM.

Para obter informações detalhadas sobre os modelos, consulte o guia de referência de modelos do Resource Manager para tipos de recurso do Microsoft.Batch.

Modelo de conta de armazenamento

Salve o código a seguir como um arquivo chamado storageAccount.json. Este modelo define uma conta de Armazenamento do Azure, que é necessária para implantar o aplicativo na conta do Azure Batch.

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "accountName": {
            "type": "string",
            "metadata": {
                 "description": "Name of the Azure Storage Account"
             }
         }
    },
    "variables": {},
    "resources": [
        {
            "type": "Microsoft.Storage/storageAccounts",
            "name": "[parameters('accountName')]",
            "sku": {
                "name": "Standard_LRS"
            },
            "apiVersion": "2018-02-01",
            "location": "[resourceGroup().location]",
            "properties": {}
        }
    ],
    "outputs": {
        "blobEndpoint": {
          "type": "string",
          "value": "[reference(resourceId('Microsoft.Storage/storageAccounts', parameters('accountName'))).primaryEndpoints.blob]"
        },
        "resourceId": {
          "type": "string",
          "value": "[resourceId('Microsoft.Storage/storageAccounts', parameters('accountName'))]"
        }
    }
}

Modelo de conta do Batch

Salve o código a seguir como um arquivo chamado batchAccount.json. Este modelo define uma conta do Batch. A conta do Lote atua como uma plataforma para executar aplicativos em pools de nó.

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "batchAccountName": {
           "type": "string",
           "metadata": {
                "description": "Name of the Azure Batch Account"
            }
        },
        "storageAccountId": {
           "type": "string",
           "metadata": {
                "description": "ID of the Azure Storage Account"
            }
        }
    },
    "variables": {},
    "resources": [
        {
            "name": "[parameters('batchAccountName')]",
            "type": "Microsoft.Batch/batchAccounts",
            "apiVersion": "2017-09-01",
            "location": "[resourceGroup().location]",
            "properties": {
              "poolAllocationMode": "BatchService",
              "autoStorage": {
                  "storageAccountId": "[parameters('storageAccountId')]"
              }
            }
          }
    ],
    "outputs": {}
}

Modelo de pool do Lote

Salve o código a seguir como um arquivo chamado batchAccountPool.json. Este modelo cria um pool de nós e nós na conta do Lote.

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "batchAccountName": {
           "type": "string",
           "metadata": {
                "description": "Name of the Azure Batch Account"
           }
        },
        "batchAccountPoolName": {
            "type": "string",
            "metadata": {
                 "description": "Name of the Azure Batch Account Pool"
             }
         }
    },
    "variables": {},
    "resources": [
        {
            "name": "[concat(parameters('batchAccountName'),'/', parameters('batchAccountPoolName'))]",
            "type": "Microsoft.Batch/batchAccounts/pools",
            "apiVersion": "2017-09-01",
            "properties": {
                "deploymentConfiguration": {
                    "virtualMachineConfiguration": {
                        "imageReference": {
                            "publisher": "MicrosoftWindowsServer",
                            "offer": "WindowsServer",
                            "sku": "2022-datacenter",
                            "version": "latest"
                        },
                        "nodeAgentSkuId": "batch.node.windows amd64"
                    }
                },
                "vmSize": "Standard_D2s_v3"
            }
          }
    ],
    "outputs": {}
}

Modelo do orquestrador

Salve o código a seguir como um arquivo chamado deployment.json. Este modelo final atua como um orquestrador para implantar os três modelos de funcionalidade subjacentes.

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "StorageContainerUri": {
           "type": "string",
           "metadata": {
                "description": "URI of the Blob Storage Container containing the Azure Resource Manager templates"
            }
        },
        "StorageContainerSasToken": {
           "type": "string",
           "metadata": {
                "description": "The SAS token of the container containing the Azure Resource Manager templates"
            }
        },
        "applicationStorageAccountName": {
            "type": "string",
            "metadata": {
                 "description": "Name of the Azure Storage Account"
            }
         },
        "batchAccountName": {
            "type": "string",
            "metadata": {
                 "description": "Name of the Azure Batch Account"
            }
         },
         "batchAccountPoolName": {
             "type": "string",
             "metadata": {
                  "description": "Name of the Azure Batch Account Pool"
              }
          }
    },
    "variables": {},
    "resources": [
        {
            "apiVersion": "2017-05-10",
            "name": "storageAccountDeployment",
            "type": "Microsoft.Resources/deployments",
            "properties": {
                "mode": "Incremental",
                "templateLink": {
                  "uri": "[concat(parameters('StorageContainerUri'), 'arm-templates/storageAccount.json', parameters('StorageContainerSasToken'))]",
                  "contentVersion": "1.0.0.0"
                },
                "parameters": {
                    "accountName": {"value": "[parameters('applicationStorageAccountName')]"}
                }
            }
        },
        {
            "apiVersion": "2017-05-10",
            "name": "batchAccountDeployment",
            "type": "Microsoft.Resources/deployments",
            "dependsOn": [
                "storageAccountDeployment"
            ],
            "properties": {
                "mode": "Incremental",
                "templateLink": {
                  "uri": "[concat(parameters('StorageContainerUri'), 'arm-templates/batchAccount.json', parameters('StorageContainerSasToken'))]",
                  "contentVersion": "1.0.0.0"
                },
                "parameters": {
                    "batchAccountName": {"value": "[parameters('batchAccountName')]"},
                    "storageAccountId": {"value": "[reference('storageAccountDeployment').outputs.resourceId.value]"}
                }
            }
        },
        {
            "apiVersion": "2017-05-10",
            "name": "poolDeployment",
            "type": "Microsoft.Resources/deployments",
            "dependsOn": [
                "batchAccountDeployment"
            ],
            "properties": {
                "mode": "Incremental",
                "templateLink": {
                  "uri": "[concat(parameters('StorageContainerUri'), 'arm-templates/batchAccountPool.json', parameters('StorageContainerSasToken'))]",
                  "contentVersion": "1.0.0.0"
                },
                "parameters": {
                    "batchAccountName": {"value": "[parameters('batchAccountName')]"},
                    "batchAccountPoolName": {"value": "[parameters('batchAccountPoolName')]"}
                }
            }
        }
    ],
    "outputs": {}
}

Configurar seu repositório

Carregue os modelos do ARM, o aplicativo FFmpeg e um arquivo de definição de build YAML no repositório Azure Repos.

Carregue os quatro modelos do ARM em uma pasta arm-templates em seu repositório.
Para o pacote de aplicativos, baixe e extraia a versão Windows de 64 bits do FFmpeg 4.3.1 e carregue-a em uma pasta hpc-application em seu repositório.

Para a definição de build, salve a definição a seguir como um arquivo chamado hpc-app.build.yml e carregue-a em uma pasta de pipelines em seu repositório.

# To publish an application into Batch, you need to
# first zip the file, and then publish an artifact, so
# you can take the necessary steps in your release pipeline.
steps:
# First, zip up the files required in the Batch account.
# For this instance, those are the ffmpeg files.
- task: ArchiveFiles@2
  displayName: 'Archive applications'
  inputs:
    rootFolderOrFile: hpc-application
    includeRootFolder: false
    archiveFile: '$(Build.ArtifactStagingDirectory)/package/$(Build.BuildId).zip'
# Publish the zip file, so you can use it as part
# of your Release pipeline later.
- task: PublishPipelineArtifact@0
  inputs:
    artifactName: 'hpc-application'
    targetPath: '$(Build.ArtifactStagingDirectory)/package'

Quando terminar de configurar o repositório, a estrutura de pastas deverá ter as seguintes seções principais:

Uma pasta arm-templates que contém os modelos do ARM.
Uma pasta hpc-application que contém ffmpeg.
Uma pasta pipelines que contém o arquivo de definição de build YAML para o pipeline de build.

Captura de tela da estrutura do repositório.

Note

Esta estrutura de base de código de exemplo demonstra que você pode armazenar o aplicativo, a infraestrutura e o código de pipeline no mesmo repositório.

Criar o pipeline do Azure

Depois de configurar o repositório de código-fonte, use Azure Pipelines para implementar um pipeline de build, teste e implantação para seu aplicativo. Nesta fase de um pipeline, você normalmente executa testes para validar o código e compilar partes do software. O número e os tipos de testes e quaisquer outras tarefas executadas dependem da estratégia geral de build e lançamento.

Criar o pipeline de build

Nesta seção, você criará um pipeline de compilação YAML para trabalhar com o software ffmpeg que é executado na conta do Batch.

Em seu projeto de Azure DevOps, selecione Pipelines na navegação à esquerda e selecione Novo pipeline.
Na tela Onde está seu código, selecione Azure Repos Git.
Na tela Selecionar um repositório , selecione seu repositório.

Note

Você também pode criar um pipeline de build usando um designer visual. Na página Novo pipeline, selecione Usar o editor clássico. Você pode usar um modelo YAML no designer visual. Para obter mais informações, confira Definir seu pipeline Clássico.
Na tela Configurar seu pipeline, selecione Arquivo YAML existente do Azure Pipelines.
Na tela Selecionar um arquivo YAML existente , selecione o arquivo hpc-app.build.yml no repositório e selecione Continuar.
Na tela Examinar o YAML do pipeline, examine a configuração de build e selecione Executar ou selecione o cursor suspenso ao lado de Executar e selecione Salvar. Esse modelo permite a integração contínua, portanto, o build é disparado automaticamente quando uma nova confirmação no repositório atende às condições definidas no build.
Você pode visualizar atualizações do progresso da compilação em tempo real. Para ver os resultados da compilação, selecione a execução apropriada na sua definição de compilação no Azure Pipelines.

Note

Se você usar um aplicativo cliente para executar sua solução HPC, precisará criar uma definição de build separada para esse aplicativo. Para obter guias de instruções, consulte a documentação do Azure Pipelines.

Criar o pipeline de Release

Você usa um pipeline de lançamento do Azure Pipelines para implantar seu aplicativo e a infraestrutura subjacente. Os pipelines de lançamento habilitam o CD e automatizam o processo de lançamento. Há várias etapas para implantar seu aplicativo e a infraestrutura subjacente.

Os modelos vinculados para esta solução devem estar acessíveis por meio de um endpoint HTTP ou HTTPS público. Esse ponto de extremidade pode ser um repositório GitHub, uma conta de Armazenamento de Blobs do Azure ou outro local de armazenamento. Para garantir que os artefatos de modelo carregados permaneçam seguros, mantenha-os em um modo privado, mas acesse-os usando algum tipo de token SAS (assinatura de acesso compartilhado).

O exemplo a seguir demonstra como implantar uma infraestrutura e um aplicativo usando modelos de um blob de Armazenamento do Azure.

Configurar o pipeline

Em seu projeto de Azure DevOps, selecioneLançamentos de > na navegação à esquerda.
Na próxima tela, selecione Novo>Novo pipeline de lançamento.
Na tela Selecionar um modelo, selecione Tarefa vazia e feche a tela Fase.
Selecione Novo pipeline de lançamento na parte superior da página e renomeie o pipeline para algo relevante para o seu pipeline, como Implantar Lote do Azure + Pool.
Na seção Artefatos , selecione Adicionar.
Na tela Adicionar um artefato, selecione Build e, em seguida, selecione seu pipeline de build para obter a saída do aplicativo HPC.

Note

Você pode criar um alias de origem ou aceitar o padrão. Anote o valor do alias de origem, pois você precisa dele para criar tarefas na definição de versão.
Selecione Adicionar.
Na página do pipeline, selecione Adicionar ao lado de Artefatos para criar um vínculo para outro artefato: o seu repositório do Azure Repos. Esse link é necessário para acessar os modelos do ARM em seu repositório. Os modelos do ARM não precisam de compilação, portanto, você não precisa submetê-los a um pipeline de compilação.

Note

Observe novamente o valor do alias de origem a ser usado posteriormente.

Selecione a guia Variáveis. Crie as variáveis a seguir no seu pipeline para que você não precise inserir novamente as mesmas informações em várias tarefas.

Nome	Valor
applicationStorageAccountName	Nome da conta de armazenamento para manter os binários do aplicativo HPC.
batchAccountApplicationName	Nome do aplicativo na conta do Batch.
batchAccountName	Nome da conta do Batch.
batchAccountPoolName	Nome do pool de máquinas virtuais (VMs) para fazer o processamento.
batchApplicationId	ID exclusivo para a aplicação Batch, no formato: `/subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>^` `/providers/Microsoft.Batch/batchAccounts/<batchAccountName>^` `/applications/<batchAccountApplicationName>`. Substitua o espaço reservado `<subscriptionId>` pela ID da sua assinatura do Azure e os outros espaços reservados pelos valores que você definiu para as demais variáveis nesta lista.
batchApplicationVersion	Versão semântica do seu aplicativo Batch, neste caso 4.3.1.
localização	Região do Azure para os recursos a serem implantados.
resourceGroupName	Nome do grupo de recursos no qual implantar recursos.
storageAccountName	Nome da conta de armazenamento para manter os modelos do ARM vinculados.
StorageContainerSasToken	`$(<referenceName>.StorageContainerSasToken)`. Substitua o placeholder `<referenceName` pelo valor de Reference name configurado na seção Variáveis de Saída da etapa Azure File Copy a seguir.
URI do contêiner de armazenamento	`$(<referenceName>.StorageContainerUri)`. Substitua o `<referenceName>` marcador pelo valor de Nome de referência que você configura na seção Variáveis de Saída da etapa Cópia de Arquivo do Azure.

Captura de tela mostrando as variáveis definidas para a versão Azure Pipelines.

Selecione a guia Tarefas e selecione o trabalho do Agente.
Na tela Trabalho do agente, em Pool de agentes, selecione Azure Pipelines.
Em Especificação do Agente, selecione windows-latest.

Adicionar tarefas

Crie seis tarefas para:

Baixe os arquivos ffmpeg compactados.
Implante uma conta de armazenamento para hospedar os modelos aninhados do ARM.
Copie os modelos do ARM para a conta de armazenamento.
Implante a conta do Batch e as dependências necessárias.
Crie uma aplicação na conta do Batch.
Carregue o pacote do aplicativo para a conta do Batch.

Para cada nova tarefa especificada pelas etapas a seguir:

Selecione o símbolo ao lado do +trabalho do Agente no painel esquerdo.
Pesquise e selecione a tarefa especificada no painel direito.
Adicione ou selecione as propriedades para configurar a tarefa.
Selecione Adicionar.

Crie as tarefas da seguinte maneira:

Selecione a tarefa Baixar Artefatos de Pipeline e defina as seguintes propriedades:
- Nome de exibição: Insira Download ApplicationPackage to Agent.
- Nome do artefato: insira hpc-application.
- Diretório de destino: Enter $(System.DefaultWorkingDirectory).
Crie uma conta Armazenamento do Azure para armazenar seus modelos do ARM. Você pode usar uma conta de armazenamento existente, mas para dar suporte a esse exemplo autocontido e isolamento de conteúdo, crie uma conta de armazenamento dedicada.

Selecione a tarefa Implantação de modelo ARM: escopo de Grupo de Recursos e defina as seguintes propriedades:
- Nome de exibição: Insira Implantar conta de armazenamento para modelos do ARM.
- Conexão do Azure Resource Manager: Selecione a assinatura do Azure apropriada.
- Assinatura: Selecione a assinatura de Azure apropriada.
- Ação: selecione Criar ou atualizar grupo de recursos.
- Grupo de recursos: Insira $(resourceGroupName).
- Localização: Insira $(location).
- Modelo: Insira $(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/storageAccount.json. Substitua o marcador <AzureRepoArtifactSourceAlias> pelo alias Source do repositório que você anotou anteriormente.
- Substituir parâmetros de modelo: insira -accountName $(storageAccountName).
Carregue os artefatos do controle do código-fonte na conta de armazenamento. Parte desta tarefa de Cópia de Arquivos do Azure grava o URI do contêiner da conta de armazenamento e o token SAS em uma variável, para que possam ser reutilizados em etapas posteriores.

Selecione a tarefa Azure Cópia de Arquivo e defina as seguintes propriedades:
- Nome de exibição: Digite AzureBlob File Copy.
- Fonte: Insira $(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/. Substitua o marcador <AzureRepoArtifactSourceAlias> pelo alias Source do repositório que você anotou anteriormente.
- assinatura Azure: selecione a assinatura de Azure apropriada.
- Tipo de destino: selecione Azure Blob.
- Conta de Armazenamento do RM: Insira $(storageAccountName).
- Nome do contêiner: insira modelos.
- Nome da referência: expanda variáveis de saída e insiraffmpeg.
Note

Se essa etapa falhar, verifique se sua organização Azure DevOps tem a função colaborador do Blob de Armazenamento na conta de armazenamento.
Implante o modelo do ARM do orquestrador para criar a conta e o pool do Lote. Esse modelo inclui parâmetros para o URI de contêiner da conta de armazenamento e o token SAS. As variáveis necessárias no modelo ARM ficam armazenadas na seção de variáveis da definição de versão e foram definidas pela tarefa AzureBlob File Copy.

Selecione a tarefa Implantação de modelo ARM: escopo de Grupo de Recursos e defina as seguintes propriedades:
- Nome de exibição: Digite Deploy Lote do Azure.
- Conexão do Azure Resource Manager: Selecione a assinatura do Azure apropriada.
- Assinatura: Selecione a assinatura de Azure apropriada.
- Ação: selecione Criar ou atualizar grupo de recursos.
- Grupo de recursos: Insira $(resourceGroupName).
- Localização: Insira $(location).
- Local do modelo: selecione a URL do arquivo.
- Link do modelo: Insira $(StorageContainerUri)arm-templates/deployment.json$(StorageContainerSasToken).
- Substituir parâmetros de modelo: insira -StorageContainerUri $(StorageContainerUri) -StorageContainerSasToken $(StorageContainerSasToken) -applicationStorageAccountName $(applicationStorageAccountName) -batchAccountName $(batchAccountName) -batchAccountPoolName $(batchAccountPoolName).
Uma prática comum é usar tarefas Azure Key Vault. Se a entidade de serviço conectada à sua assinatura do Azure tiver uma política de acesso apropriada configurada, ela poderá baixar segredos do Key Vault, que poderão ser usados como variáveis no seu pipeline. O nome do segredo é definido com o valor associado. Por exemplo, você pode referenciar um segredo do sshPassword com $(sshPassword) na definição de versão.
Chame CLI do Azure para criar um aplicativo no Lote do Azure.

Selecione a tarefa CLI do Azure e defina as seguintes propriedades:
- Nome de exibição: Digite Criar aplicação na conta do Lote do Azure.
- Conexão do Azure Resource Manager: Selecione a assinatura do Azure apropriada.
- Tipo de script: selecione o PowerShell Core.
- Localização do script: Selecione script embutido.
- Script embutido: Insira az batch application create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName).
Chame CLI do Azure para carregar pacotes associados ao aplicativo, nesse caso, os arquivos ffmpeg.

Selecione a tarefa CLI do Azure e defina as seguintes propriedades:
- Nome de exibição: Digite Carregar pacote na conta do Lote do Azure.
- Conexão do Azure Resource Manager: Selecione a assinatura do Azure apropriada.
- Tipo de script: selecione o PowerShell Core.
- Localização do script: Selecione script embutido.
- Script embutido: Insira az batch application package create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName) --version $(batchApplicationVersion) --package-file=$(System.DefaultWorkingDirectory)/$(Release.Artifacts.<AzureBuildArtifactSourceAlias>.BuildId).zip. Substitua o marcador <AzureBuildArtifactSourceAlias> pelo alias da Fonte de Compilação que você anotou anteriormente.
Note

O número de versão do pacote do aplicativo é definido como uma variável. A variável permite sobrescrever versões anteriores do pacote e controlar manualmente a versão do pacote enviada ao Lote do Azure.

Criar e executar a versão

Quando terminar de criar todas as etapas, selecione Salvar na parte superior da página do pipeline e selecione OK.
Selecione Criar versão na parte superior da página.
Para exibir o status da versão ao vivo, selecione o link na parte superior da página que diz que a versão foi criada.
Para visualizar a saída do log do agente, passe o mouse sobre a etapa e, em seguida, selecione o botão Logs.

Testar o ambiente

Depois que o ambiente for configurado, confirme se os testes a seguir são executados com êxito. Substitua os espaços reservados pelo nome do seu grupo de recursos e conta do Lote.

Conectar à conta do Batch

Conecte-se à nova conta do Azure Batch usando o CLI do Azure em um prompt de comando.

Entre em sua conta az login Azure e siga as instruções para autenticar.
Autentique a conta do Batch com az batch account login -g <resourceGroup> -n <batchAccount>.

Listar os aplicativos disponíveis

az batch application list -g <resourceGroup> -n <batchAccount>

Verifique se o pool é válido

az batch pool list

Na saída do comando, observe o valor de currentDedicatedNodes para ajustar no próximo teste.

Redimensionar o pool

Execute o comando a seguir para redimensionar o pool para que haja nós de computação disponíveis para teste de trabalho e tarefa. Substitua o marcador <poolName> pelo valor do nome do seu pool e o marcador <targetNumber> por um número maior que o currentDedicatedNodes na saída do comando anterior. Verifique o status executando o az batch pool list comando até que o redimensionamento seja concluído e mostre o número de destino de nós.

az batch pool resize --pool-id <poolname> --target-dedicated-nodes <target number>

Próximas Etapas

Confira estes tutoriais para aprender a interagir com uma conta do Batch por meio de um aplicativo simples.

Comentários

Esta página foi útil?

Last updated on 2026-06-23