Compartilhar via

Recomendações para otimizar o código e a infraestrutura

  • Artigo

Aplica-se a esta recomendação de lista de verificação de Eficiência de Desempenho do Azure Well-Architected Framework:

PE:07 Otimize o código e a infraestrutura. Use o código com desempenho e verifique se ele descarrega as responsabilidades para a plataforma. Use código e infraestrutura somente para sua finalidade principal e somente quando necessário.

Este guia descreve as recomendações para otimizar o desempenho de código e infraestrutura. Para otimizar seu código e infraestrutura, você deve usar seus componentes apenas para a finalidade principal e somente quando necessário. Quando você usa código e infraestrutura em excesso, ele cria consumo desnecessário de recursos, gargalos e respostas lentas. Para compensar essas ineficiências, você deve adicionar mais recursos para realizar as mesmas tarefas.

Definições

Termo Definição
Simultaneidade Quando várias tarefas ou processos são executados ao mesmo tempo, mas não necessariamente ao mesmo tempo.
Arquitetura da CPU Os componentes e os princípios que afetam como o computador funciona.
Compactação de dados A ação de reduzir o tamanho dos arquivos minimizando dados redundantes.
Pilha Uma área na memória usada para alocações de memória de runtime.
Vazamento de memória Quando uma carga de trabalho falha ao liberar memória alocada depois que a memória não for mais necessária.
Paralelismo Quando várias tarefas ou processos são executados ao mesmo tempo.

Principais estratégias de design

Otimizar o código e a infraestrutura envolve ajustar o código e a infraestrutura de suporte para melhorar a eficiência do desempenho. Ele requer um código de desempenho que executa tarefas rapidamente e não desperdiça recursos. Ele requer uma infraestrutura bem projetada que é simplificada para evitar complexidade desnecessária. Uma carga de trabalho deve usar os recursos inerentes da plataforma. É uma abordagem que ajuda a garantir que o código e a infraestrutura sejam usados principalmente para suas finalidades principais e somente quando necessário.

Otimizar o desempenho do código

Para otimizar o desempenho do código, modifique o código para reduzir o uso de recursos, minimizar o runtime e melhorar o desempenho. Você pode modificar o código para melhorar a eficiência e a velocidade de um programa de software. Não mascarar problemas de desempenho com força bruta. Força bruta significa adicionar recursos de computação para compensar o desempenho do código, como adicionar capacidade extra em vez de abordar a origem. Você precisa corrigir problemas de desempenho com otimização. Quando você otimiza o desempenho do código, ele ajuda a maximizar a utilização de recursos do sistema, melhora o tempo de resposta, reduz a latência e melhora a experiência do usuário.

Instrumentalize seu código

O código de instrumentação refere-se à prática de adicionar snippets de código ou bibliotecas a códigos que coletam dados e monitoram o desempenho do código durante o runtime. A instrumentação de código permite que os desenvolvedores coletem informações sobre as principais métricas, como consumo de recursos (CPU, uso de memória) e tempo de execução. Ao instrumentar o código, os desenvolvedores podem obter insights sobre caminhos quentes de código, identificar gargalos de desempenho e otimizar o código para obter melhor eficiência de desempenho.

Em um ambiente ideal, você deve fazer a análise de código no início do ciclo de vida de desenvolvimento de software. Quanto mais cedo você pegar um problema de código, mais barato será corrigi-lo. Você deseja automatizar o máximo possível dessa análise de código. Use ferramentas de análise de código dinâmico e estático para reduzir o esforço manual. No entanto, tenha em mente que esse teste ainda é uma simulação de produção. A produção fornece a compreensão mais clara da otimização de código.

Compensação: as ferramentas de monitoramento de código provavelmente aumentarão os custos.

Identificar caminhos quentes

Ao instrumentar seu código, você pode medir o consumo de recursos para caminhos de código diferentes. Essas medidas ajudam você a identificar caminhos quentes. Os caminhos quentes têm um efeito significativo no desempenho e no uso de recursos. São seções críticas ou executadas com frequência de um programa que exigem alto desempenho e baixa latência. Para identificar caminhos quentes de código, considere estas etapas:

  • Analisar dados de runtime: colete dados de runtime e analise-os para identificar áreas do código que consomem recursos significativos, como operações de CPU, memória ou E/S. Procure padrões ou seções de código que são executados com frequência ou demoram muito para serem concluídos.

  • Medir o desempenho: use ferramentas de criação de perfil ou estruturas de teste de desempenho para medir o tempo de execução e o consumo de recursos de caminhos de código diferentes. Ele ajuda a identificar gargalos e áreas para melhoria.

  • Considere a lógica de negócios e o efeito do usuário: avalie a importância de caminhos de código diferentes com base em sua relevância para a funcionalidade do aplicativo ou operações comerciais críticas. Determine quais caminhos de código são cruciais para fornecer valor aos usuários ou atender aos requisitos de desempenho.

Otimizar a lógica de código

Otimizar a lógica de código é refinar a estrutura e o design do código para executar tarefas com menos recursos. A lógica aprimorada reduz operações desnecessárias. Ele cria uma execução mais rápida com menos consumo de recursos. Você deve remover quaisquer operações desnecessárias no caminho do código que possam afetar o desempenho. Priorize a otimização de caminhos quentes para ver os maiores ganhos de eficiência de desempenho. Para otimizar a lógica de código, considere as seguintes estratégias:

  • Remover chamadas de função desnecessárias: examine seu código e identifique as funções que não são essenciais para a funcionalidade desejada e podem afetar negativamente o desempenho. Por exemplo, se uma chamada de função executar uma validação concluída anteriormente no código, você poderá remover a chamada de função de validação desnecessária.

  • Minimizar operações de log: o registro em log pode ser útil para depuração e análise, mas o registro em log excessivo pode afetar o desempenho. Avalie a necessidade de cada operação de registro em log e remova todas as chamadas de registro em log desnecessárias que não sejam críticas para análise de desempenho.

  • Otimizar loops e condicionais: analise loops e condicionais em seu código e identifique quaisquer iterações ou condições desnecessárias que possam ser eliminadas. Simplificar e otimizar essas estruturas pode melhorar o desempenho do código. Minimize as chamadas de função em loops e elimine cálculos redundantes. Considere mover cálculos para fora do loop ou usar o cancelamento do registro de loop.

  • Reduzir o processamento desnecessário de dados: examine seu código para quaisquer operações desnecessárias de processamento de dados, como cálculos ou transformações redundantes. Elimine essas operações desnecessárias para melhorar a eficiência do seu código.

  • Otimizar estruturas de dados. Para armazenar e recuperar dados com eficiência, selecione estruturas de dados apropriadas, como matrizes, listas vinculadas, árvores e tabelas de hash. Escolha a melhor estrutura de dados para um problema específico. Uma estrutura de dados adequada melhora o desempenho do aplicativo.

  • Minimizar solicitações de rede: se o código envolve fazer solicitações de rede, minimize o número de solicitações e otimize seu uso. Solicitações em lote quando possível e evite viagens de ida e volta desnecessárias para melhorar o desempenho.

  • Minimizar alocações: identifique áreas em que ocorre alocação excessiva de memória. Otimize o código reduzindo alocações desnecessárias e reutilizando recursos existentes quando possível. Minimizando alocações, você pode melhorar a eficiência da memória e o desempenho geral. Use as estratégias apropriadas de gerenciamento de memória e coleta de lixo para sua linguagem de programação.

  • Reduzir o tamanho da estrutura de dados: avalie o tamanho das estruturas de dados, como classes, e identifique as áreas em que a redução é possível. Examine os requisitos de dados e elimine quaisquer campos ou propriedades desnecessários. Otimize o uso de memória selecionando tipos de dados apropriados e empacotando dados com eficiência.

  • Use SDKs e bibliotecas com otimização de desempenho. Use SDKs nativos ou bibliotecas com otimização de desempenho. Os SDKs nativos são projetados para interagir com os serviços e recursos em uma plataforma ou dentro de uma estrutura. Por exemplo, os SDKs nativos de nuvem funcionam melhor com planos de dados de serviço de nuvem do que com acesso personalizado à API. Os SDKs se destacam em lidar com solicitações de rede e otimizar interações. Bibliotecas com otimização de desempenho, como Math.NET, contêm funções com otimização de desempenho. Ao aplicar as funções adequadamente, você pode melhorar o desempenho da carga de trabalho.

  • Implementação de corte cruzado: considere os efeitos de implementações de corte cruzado, como verificações de middleware ou token, e avalie se elas afetam negativamente o desempenho.

Examine as recomendações de desempenho específicas para a linguagem de programação com a qual você está trabalhando. Avalie seu código em relação a essas recomendações para identificar áreas de melhoria.

Compensações:

  • Otimizar o código e os caminhos quentes requer experiência do desenvolvedor na identificação de ineficiências de código é subjetivo e pode ser um indivíduo altamente qualificado necessário para outras tarefas.
  • Os SDKs fornecem conveniência e eliminam as complexidades de interagir com APIs. Mas os SDKs podem limitar suas opções de controle e personalização para código personalizado.

Otimizar o gerenciamento de memória

A otimização do gerenciamento de memória envolve a refinação da maneira como uma carga de trabalho usa, aloca e libera recursos de memória para melhorar a eficiência. O gerenciamento de memória adequado melhora o desempenho do código porque reduz a sobrecarga das operações de memória. O uso eficiente de memória reduz a latência, impede lentidão ou falhas do sistema e maximiza a taxa de transferência de tarefas computacionais. Considere as estratégias a seguir para otimizar o gerenciamento de memória.

Depurar problemas de memória. Despejos de memória são instantâneos de memória do aplicativo. Eles capturam o estado de memória de um aplicativo em um ponto específico no tempo. Os despejos de memória permitem a análise retrospectiva de problemas relacionados à memória. Selecione o tipo apropriado de despejo de memória com base na natureza do problema que você está tentando diagnosticar e os recursos disponíveis. Você deve usar despejos em miniatura para depuração de rotina e despejos completos para problemas complexos e críticos. Essa estratégia fornece um equilíbrio entre o uso de recursos e os recursos de diagnóstico. Muitos serviços de hospedagem de código dão suporte à depuração de memória. Você deve preferir serviços que dão suporte à análise de memória em vez dos serviços que não dão. Estas são as etapas básicas para depurar problemas de memória:

  1. Capturar despejos de memória: comece configurando um mecanismo para capturar despejos de memória durante o runtime do aplicativo. A captura pode ser disparada manualmente, automaticamente ou quando condições específicas (como consumo excessivo de memória) são atendidas. Alguns serviços de nuvem podem já oferecer esse processo.

  2. Analisar despejos de memória: depois de coletar os despejos de memória, analise-os. Várias ferramentas podem ajudá-lo a inspecionar esses despejos, como WinDbg para aplicativos windows ou GDB para sistemas baseados em Unix.

  3. Identificar vazamentos de memória: concentre-se na identificação de vazamentos de memória durante a análise. Os vazamentos de memória surgem quando o aplicativo aloca memória, mas falha ao liberá-la quando a memória não é mais necessária. Pesquise objetos ou estruturas de dados que permanecem na memória mesmo quando devem ser desalocados.

  4. Correção e teste: ao identificar o código problemático, concentre-se em resolver os problemas de memória. As resoluções podem envolver liberar memória corretamente, otimizar estruturas de dados ou reavaliar práticas de gerenciamento de memória. Confirme se suas soluções passam por testes rigorosos para garantir sua eficácia.

  5. Iterar e monitorar: o gerenciamento de memória é um processo contínuo. Monitore rotineiramente o uso de memória do aplicativo e persista na coleta de despejos de memória em produção. Revisite regularmente os estágios de análise e otimização para garantir que os problemas de memória não reapareçam com modificações de código subsequentes.

Ao incorporar a análise de despejo de memória em seu ciclo de vida de desenvolvimento de software, você pode ampliar a confiabilidade e a eficiência de seus aplicativos. Ele ajuda a reduzir a probabilidade de problemas relacionados à memória na produção.

Reduzir alocações de memória. Minimize as alocações de memória para reduzir o volume de memória geral do código. Sua carga de trabalho pode utilizar a memória disponível com eficiência. Há menos necessidade de o coletor de lixo recuperar memória não usada e isso reduz a frequência e a duração dos ciclos de coleta de lixo. As alocações de memória podem ser dispendiosas, especialmente se você executá-las com frequência. Minimize as alocações de memória para que o código possa ser executado de forma rápida e eficiente.

Os caches armazenam dados acessados com frequência perto do processador, o que melhora o desempenho. Quando você minimiza as alocações de memória, há menos contenção para o espaço em cache, para que você possa utilizar efetivamente o cache. Um alto número de alocações de memória pode prejudicar o desempenho do aplicativo e gerar erros. Outras maneiras de minimizar as alocações de memória incluem:

  • Variáveis locais: use variáveis locais em vez de variáveis globais para minimizar o consumo de memória.

  • Inicialização lenta: implemente a inicialização lenta para adiar a criação de objetos ou recursos até que eles sejam necessários.

  • Buffers: gerencie buffers com eficiência para evitar alocar buffers de memória grandes.

  • Pool de objetos: considere o pool de objetos para reutilizar objetos grandes em vez de alocar e desalocá-los.

Para obter mais informações, consulte Reduzir alocações de memória e O heap de objetos grandes em sistemas Windows.

Usar simultaneidade e paralelismo

Usar simultaneidade e paralelismo envolve a execução de várias tarefas ou processos simultaneamente ou de maneira sobreposta para fazer uso eficiente dos recursos de computação. Essas técnicas aumentam a taxa de transferência geral e o número de tarefas que uma carga de trabalho pode processar. Quando você executa tarefas simultaneamente ou em paralelo, ele reduz o runtime do aplicativo e diminui a latência e aumenta os tempos de resposta. A simultaneidade e o paralelismo permitem a utilização eficiente de recursos de computação, como núcleos de CPU ou sistemas distribuídos. Simultaneidade e paralelismo distribuem efetivamente a carga de trabalho entre os recursos de computação.

Use paralelismo. Paralelismo é a capacidade de um sistema disparar simultaneamente várias tarefas ou processos em vários recursos de computação. O paralelismo divide uma carga de trabalho em tarefas menores que são executadas em paralelo. Você pode obter paralelismo usando técnicas como multiprocessamento ou computação distribuída. Distribua tarefas entre processadores multicore para otimizar o gerenciamento de carga de trabalho. Otimize o código para aproveitar a arquitetura da CPU, os modelos de threading e os processadores multicore. Quando você executa o código em paralelo, o desempenho melhora porque a carga de trabalho é distribuída entre vários núcleos.

Use simultaneidade. Simultaneidade é a capacidade de um sistema executar várias tarefas ou processos. A simultaneidade permite que diferentes partes de um programa progridam de forma independente, o que pode melhorar o desempenho geral. Você pode implementar a simultaneidade usando técnicas como multithreading, nas quais vários threads são executados simultaneamente em um único processo. Você também pode usar a programação assíncrona, na qual as tarefas são disparadas simultaneamente.

  • Programação assíncrona: a programação assíncrona é uma abordagem para disparar tarefas sem bloquear o thread main. A programação assíncrona permite que um programa dispare tarefas enquanto aguarda a conclusão de operações de longa execução. Com a programação assíncrona, o programa pode iniciar várias tarefas e esperar que elas sejam concluídas de forma assíncrona. O programa não precisa aguardar a conclusão de cada tarefa antes de passar para a próxima.

    Há muitas técnicas e padrões de programação assíncronos, dependendo da linguagem de programação e da plataforma. Uma abordagem comum é usar palavras-chave e constructos assíncronos, como async e await, em linguagens como C#. Com essas palavras-chave, você pode definir métodos assíncronos. Para tráfego HTTP, considere usar o padrão de Request-Reply assíncrona.

    Muitas estruturas e bibliotecas fornecem suporte interno para programação assíncrona. Por exemplo, na plataforma .NET, você pode implementar operações assíncronas usando padrões como padrão assíncrono baseado em tarefa e padrão assíncrono baseado em evento. A implementação específica da programação assíncrona varia dependendo da linguagem de programação, da plataforma e dos requisitos do aplicativo.

  • Filas: uma fila é um buffer de armazenamento localizado entre um componente solicitante (produtor) e o componente de processamento (consumidor) da carga de trabalho. Pode haver vários consumidores para uma única fila. À medida que as tarefas aumentam, você deve dimensionar os consumidores para atender à demanda. O produtor coloca tarefas em uma fila. A fila armazena as tarefas até que um consumidor tenha capacidade. Uma fila geralmente é a melhor maneira de entregar o trabalho a um serviço de processamento que experimenta picos de demanda. Para obter mais informações, consulte Padrão de nivelamento de carga baseado em fila e Filas de armazenamento e filas do Barramento de Serviço.

Usar o pool de conexões

O pool de conexões é a prática de reutilizações estabelecidas conexões de banco de dados em vez de criar uma nova conexão para cada solicitação. Pode ser caro estabelecer uma conexão com um banco de dados. Você precisa criar uma conexão de rede autenticada com o servidor de banco de dados remoto. As conexões de banco de dados são especialmente caras para aplicativos que frequentemente abrem novas conexões. O pool de conexões reutiliza conexões existentes e elimina a despesa de abrir uma nova conexão para cada solicitação. O pool de conexões reduz a latência de conexão e permite alta taxa de transferência de banco de dados (transações por segundo) no servidor. Você deve escolher um tamanho de pool que possa lidar com mais conexões do que tem atualmente. A meta é fazer com que o pool de conexões lide rapidamente com novas solicitações de entrada.

Entenda os limites de pool de conexões. Alguns serviços limitam o número de conexões de rede. Quando você excede esse limite, as conexões podem diminuir ou terminar. Você pode usar o pool de conexões para estabelecer um conjunto fixo de conexões no momento da inicialização e, em seguida, manter essas conexões. Em muitos casos, um tamanho de pool padrão pode consistir em apenas algumas conexões que são executadas rapidamente em cenários de teste básicos. Seu aplicativo pode esgotar o tamanho do pool padrão em escala e criar um gargalo. Você deve estabelecer um tamanho de pool que mapeia para o número de transações simultâneas com suporte em cada instância do aplicativo.

Teste o pool de conexões. Cada banco de dados e plataforma de aplicativo tem requisitos ligeiramente diferentes para configurar e usar um pool. Teste o pool de conexões para garantir que ele funcione com eficiência sob carga.

Risco: o pool de conexões pode criar fragmentação de pool e degradar o desempenho.

Otimizar trabalhos em segundo plano

Muitos aplicativos exigem tarefas em segundo plano que são executadas independentemente da interface do usuário. O aplicativo pode iniciar o trabalho e continuar processando solicitações interativas dos usuários. Exemplos de trabalhos em segundo plano incluem trabalhos em lotes, tarefas com uso intensivo de processador e processos de execução longa, como fluxos de trabalho. As tarefas em segundo plano não devem bloquear o aplicativo nem causar inconsistências devido à operação atrasada quando o sistema está sob carga. Para melhorar o desempenho, você pode dimensionar instâncias de computação que hospedam tarefas em segundo plano. Para obter mais informações, consulte Trabalhos em segundo plano e Considerações sobre dimensionamento e desempenho.

Otimizar o desempenho da infraestrutura

Otimizar o desempenho da infraestrutura significa melhorar e ajustar elementos de infraestrutura para garantir a operação de pico e o melhor uso de recursos para uma carga de trabalho. Ao ajustar a infraestrutura, você pode minimizar o desperdício, reduzir os atrasos e obter mais com os recursos disponíveis. Ele garante que as cargas de trabalho sejam executadas de forma confiável e rápida, levando a melhores experiências do usuário e economia de custos. Para otimizar o desempenho da infraestrutura, considere as seguintes estratégias:

Adicionar limites de uso. Você pode implementar limites de uso em alguns componentes de carga de trabalho. Por exemplo, para remover pods instáveis, você pode definir os limites de CPU e memória do pod no AKS (Serviço de Kubernetes do Azure). Para otimizar o desempenho, você pode definir limites de memória em VMs (máquinas virtuais) Java.

Simplifique a infraestrutura. Simplifique sua carga de trabalho para reduzir o potencial de problemas de interação, dependência e compatibilidade. Ao simplificar sua carga de trabalho, você otimiza a utilização de recursos de memória, capacidade de processamento e armazenamento.

Reduza a carga. Para reduzir a carga em uma carga de trabalho, minimize a demanda colocada em um aplicativo e habilite os recursos para executar suas tarefas primárias. Por exemplo, é uma prática comum evitar a execução de soluções de segurança em seu código ou em instâncias de computação individuais. Em vez disso, os servidores Web devem atender a solicitações HTTP. Os firewalls de aplicativo Web e os recursos de gateway podem lidar com verificações de segurança. As estratégias a seguir ajudam a reduzir a carga em sua carga de trabalho:

  • Consistência eventual: adote um modelo de consistência eventual para melhorar o desempenho, permitindo que os dados sejam ligeiramente datados. A consistência eventual reduz a demanda imediata por ciclos de CPU e largura de banda de rede para atualizações de dados constantes.

  • Delegar tarefas: delegar tarefas de servidor a clientes ou intermediários, como índices de pesquisa e caches. Delegar tarefas como classificar dados, filtrar dados ou renderizar exibições. Ao descarregar essas tarefas, você reduz a carga de trabalho em seus servidores e melhora o desempenho.

Otimize a rede. Para otimizar uma rede de carga de trabalho para desempenho, configure e ajuste a infraestrutura de rede. Verifique se a carga de trabalho pode operar no nível mais alto de eficiência.

  • Protocolos de rede: atualize para protocolos modernos, como HTTP/2, que permitem que várias solicitações sejam enviadas por uma única conexão. Os protocolos modernos reduzem a sobrecarga de estabelecer novas conexões.

    Compensação: os protocolos modernos podem excluir clientes mais antigos.

  • Chateação de rede: a rede do Lote solicita em conjunto para reduzir o número de solicitações. Em vez de fazer várias solicitações pequenas, combine-as em solicitações maiores para reduzir a sobrecarga de rede.

  • Consultas de banco de dados: verifique se as consultas de banco de dados recuperam apenas as informações necessárias. Evite recuperar grandes quantidades de dados desnecessários, o que pode levar ao aumento do tráfego de rede e ao desempenho lento.

  • Dados estáticos: utilize uma rede de distribuição de conteúdo para armazenar em cache conteúdo estático acessado com frequência próximo aos usuários. Quando você armazena dados em cache, eles não precisam percorrer longas distâncias. O cache melhora os tempos de resposta e reduz o tráfego de rede.

  • Coleta de logs: colete e mantenha apenas os dados de log necessários para dar suporte aos seus requisitos. Configure regras de coleta de dados e implemente considerações de design para otimizar os custos do Log Analytics.

  • Compactação de dados: compacte e agrupe conteúdo HTTP e dados de arquivo para permitir a transmissão rápida entre clientes e servidores. A compactação reduz os dados que uma página ou API retorna e envia de volta para o navegador ou aplicativo cliente. A compactação otimiza o tráfego de rede, o que pode acelerar a comunicação do aplicativo.

    Compensação: a compactação adiciona processamento do lado do servidor e do lado do cliente. O aplicativo deve compactar, enviar e descompactar dados. A comunicação multicast ou a comunicação com vários destinatários podem criar sobrecarga de descompactação. Você precisa testar e medir as variações de desempenho antes e depois de implementar a compactação de dados para determinar se ela é uma boa opção para sua carga de trabalho. Para obter mais informações, consulte Compactação de resposta em ASP.NET Core.

Facilitação do Azure

Código de instrumentação: o Application Insights do Azure Monitor dá suporte à instrumentação automática (autoinstrumentação) e à instrumentação manual do código do aplicativo. A autoinstrumentação permite a coleta de telemetria sem tocar no código do aplicativo. A instrumentação manual requer alterações de código para implementar o Application Insights ou a API do OpenTelemetry. Você pode usar o Application Insights Profiler para ajudar a otimizar os caminhos quentes.

Otimizando a lógica de código: o Azure oferece SDKs e bibliotecas para várias linguagens de programação interagirem com os serviços do Azure. Use SDKs para simplificar as interações entre aplicativos e recursos do Azure. Os SDKs fornecem interação ideal com os serviços do Azure, o que reduz a latência e aumenta a eficiência.

Otimizando o gerenciamento de memória: use o recurso de detecção inteligente do Application Insights para analisar o consumo de memória e ajudar a identificar e resolver vazamentos de memória.

Serviço de Aplicativo do Azure tem um recurso de coleta e análise de despejo de memória e criador de perfil. O Serviço de Aplicativo recurso de ajuste automático pode fazer despejos de memória e rastreamentos de perfil de aplicativos .NET e Java automaticamente.

Usando simultaneidade e paralelismo: diferentes serviços do Azure fornecem suporte exclusivo para simultaneidade, como O Azure Cosmos DB, Azure Functions e Armazenamento de Blobs. Para paralelismo, os serviços do AKS dão suporte à implantação de aplicativos em contêineres, o que melhora o processamento paralelo.

Lote do Azure é um serviço de agendamento de trabalho baseado em nuvem que você pode usar para habilitar a computação paralela e de alto desempenho sem a necessidade de configuração de infraestrutura. Para obter mais informações, consulte Trabalhos em segundo plano.

Otimizando o desempenho da infraestrutura: implemente modelos de Resource Manager do Azure para definir e implantar a infraestrutura usando código. Use esses modelos para implementar implantações de recursos eficientes, repetíveis e consistentes. Azure Policy fornece recursos de governança para garantir que as implantações de recursos sigam as melhores práticas e padrões organizacionais.

Para programação assíncrona, use serviços de enfileiramento escalonáveis, como o Armazenamento de Filas do Azure e Barramento de Serviço do Azure, para facilitar a programação assíncrona. Você pode enfileirar tarefas e processá-las de forma independente. Para dar suporte a operações assíncronas, Azure Marketplace oferece filas e ferramentas de terceiros que você pode integrar aos serviços do Azure.

Lista de verificação de eficiência de desempenho

Consulte o conjunto completo de recomendações.

Lista de verificação de eficiência de desempenho