Desenvolvedores BR articles

GitHub Copilot Dev Days Online

cynthiazanoni — Thu, 14 May 2026 13:38:38 GMT

After a series of in-person events, GitHub Copilot Dev Days is now going online, bringing developers from around the world together to explore modern AI-assisted software development in practice.

Through live sessions focused on agentic development, modern workflows, and hands-on learning in VS Code, attendees will learn how to use GitHub Copilot beyond autocomplete and apply it across real development scenarios.

Register for the session that fits your language and community

GitHub Copilot Dev Days LATAM [Spanish] - May 26

A hands-on session for Spanish-speaking developers across Latin America focused on building modern applications with GitHub Copilot, TypeScript, React, and Tailwind.

Attendees will explore agentic workflows, context engineering, and practical ways to use GitHub Copilot as an active development partner in VS Code.

Date: May 26, 2026, 12 PM (Mexico City / CDMX)
Register: GitHub Copilot Dev Days LATAM | Microsoft Reactor

GitHub Copilot Dev Days Brazil [Portuguese] - May 25

This edition focuses on AI-assisted development with Python, FastAPI, and HTMX using GitHub Copilot throughout the development workflow.

The session covers practical workflows for code generation, refactoring, debugging, and day-to-day development with GitHub Copilot in VS Code.

Date: May 25, 2026, 7 PM (Brasilia Time)
Register: GitHub Copilot Dev Days Brasil | Microsoft Reactor

GitHub Copilot Dev Days 中文版 [Simplified Chinese] - May 26

This session explores how GitHub Copilot and GitHub Actions can work together to create intelligent and automated development workflows.

Topics include ChatOps, automated summaries, syncing content into GitHub Issues, and agentic workflows designed to improve collaboration and engineering efficiency.

Date: May 26, 2026, 7:30 PM (China Standard Time - CST)
Register: GitHub Copilot Dev Days - 中文版 | Microsoft Reactor

GitHub Copilot Dev Days [English] - May 27

An English-language workshop for developers who want to learn how to build modern applications with GitHub Copilot in VS Code.

The session focuses on TypeScript, React, Tailwind, and Agent Mode workflows, showing how better context and prompting can improve AI-assisted development.

Date: May 27, 2026, 9 AM (PST)
Register: GitHub Copilot Dev Days | Microsoft Reactor

All sessions are hosted through Microsoft Reactor. Check the registration pages for local times and additional event details.

APIM Circuit Breaker com Azure OpenAI

wdossantos — Tue, 28 Apr 2026 20:46:40 GMT

APIM Circuit Breaker com Azure OpenAI

Visão Geral

Ao consumir modelos do Azure OpenAI em produção, depender de um único endpoint representa um risco real. Basta uma instância ficar indisponível ou atingir limites de throttling para que toda a aplicação seja impactada.

Neste artigo, construímos uma arquitetura resiliente utilizando o Azure API Management (APIM) como camada de proteção entre o cliente e os serviços de IA.

O ponto de partida são dois backends do Azure OpenAI (oiaws01 e oiaws02), ambos configurados com Managed Identity. A partir deles, criamos um Load Balancer Pool no APIM, distribuindo o tráfego em um modelo 50/50 entre os dois endpoints.

Em seguida, habilitamos o Circuit Breaker, que detecta falhas consecutivas e "abre o circuito", impedindo que novas requisições sejam enviadas a um backend com problemas. Nesse estado, o APIM passa a responder com 503 – Service Unavailable, incluindo o header Retry-After, até que o backend se recupere.

O ponto mais crítico está na configuração das políticas XML. Posicionar o set-backend-service dentro do bloco <retry> garante que cada tentativa seja roteada novamente pelo Load Balancer, evitando que as retentativas atinjam sempre o mesmo backend com falha.

Todo o fluxo foi validado usando o Trace do APIM, onde é possível acompanhar, passo a passo:

Seleção do backend no pool
Autenticação via Managed Identity
Fallback para o segundo endpoint
Resposta final ao cliente

Por fim, exploramos a camada de observabilidade. Os eventos de abertura do Circuit Breaker são capturados e enviados para uma Storage Queue, de onde um Logic App os exporta via HTTP POST para o Elastic Observability, permitindo monitoramento em tempo real de quando e por que os circuitos são abertos.

Diagrama

Diagrama do fluxo da Requisição http, Load balancer falhas e Circuit Break

1. Criando os Backends para Azure OpenAI

O primeiro passo é registrar no APIM os endpoints que representam as instâncias do Azure OpenAI. Neste cenário, criamos dois backends apontando para:

https://oiaws01.openai.azure.com/openai
https://oiaws02.openai.azure.com/openai

Cada backend funciona como uma abstração dentro do APIM — ele encapsula a URL, as credenciais e as configurações de resiliência (como o Circuit Breaker) em um único recurso reutilizável.

Dois backends registrados no APIM: openapi01-openai-endpoint e openapi02-openai-endpoint, apontando para os respectivos endpoints do Azure OpenAI.

Configuração de Managed Identity

Para que o APIM consiga se autenticar nos backends sem expor chaves de API, configuramos Managed Identity. O Azure API Management pode apresentar credenciais ao backend utilizando cabeçalhos de autorização, parâmetros de consulta ou certificados de cliente — mas a abordagem mais segura e moderna é usar a identidade gerenciada.

Com essa configuração, o APIM solicita um token OAuth ao Azure AD usando sua própria identidade (System Assigned), e o apresenta ao backend como um Bearer token. Não há segredos para rotacionar, não há chaves para vazar.

Backend openia02-openai-endpoint configurado com Managed Identity (System Assigned) apontando para https://cognitiveservices.azure.com/.

Em alguns cenários — especialmente quando a configuração via portal não é suficiente ou quando precisamos de controle granular — é necessário configurar a autenticação diretamente nas políticas XML do APIM:

<authentication-managed-identity resource="https://cognitiveservices.azure.com" output-token-variable-name="msi-access-token" />  <set-header name="Authorization" exists-action="override"> <value>@("Bearer " + (string)context.Variables["msi-access-token"])</value> </set-header>

Essa abordagem é útil quando você precisa reutilizar o token em múltiplas policies ou quando o backend exige um formato específico de apresentação das credenciais.

Teste Básico

Com os backends e a autenticação configurados, o próximo passo é validar que tudo funciona. Um teste simples direto no console do APIM confirma a conectividade:

Parâmetros:

deployment-id: o1 api-version: 2025-01-01-preview

Request body:

{ "messages": [ { "role": "user", "content": "I am going to Paris, what should I see?" } ], "max_completion_tokens": 40000, "model": "o1" }Teste no console do APIM confirmando resposta 200 OK do Azure OpenAI (modelo o1) via Managed Identity.

2. Criando o Load Balancer (LB)

Ter dois backends funcionando individualmente é um bom começo, mas não garante resiliência por si só. Se a API estiver apontada para um backend fixo e ele cair, o serviço para. É aqui que entra o Load Balancer Pool.

O Load Balancer Pool é um recurso do APIM que agrupa múltiplos backends e distribui o tráfego entre eles segundo regras configuráveis. Em vez de apontar a política set-backend-service para um backend individual, apontamos para o pool — e o APIM se encarrega de escolher para qual instância enviar cada requisição.

Criação do Load Balancer Pool

Criamos um pool chamado LB01 contendo os dois backends OpenAI. A distribuição foi configurada como 50/50 com pesos customizados, o que significa que cada backend recebe metade do tráfego em condições normais.

Benefícios imediatos:

Distribuição de carga — nenhum backend recebe 100% das requisições
Alta disponibilidade — se um backend falhar, o outro absorve o tráfego (quando combinado com retry)
Flexibilidade — pesos e prioridades podem ser ajustados sem alterar código

Criação do Load Balancer Pool com os dois backends OpenAI, peso 50/50 e prioridades customizadas.

Com o pool criado, qualquer política que referencia backend-id="LB01" passa automaticamente a ter balanceamento de carga. Mas distribuir tráfego não é suficiente — precisamos também detectar e isolar falhas. É o que o Circuit Breaker faz.

3. Entendendo e Configurando o Circuit Breaker

O que é o Circuit Breaker?

O Circuit Breaker é um padrão de resiliência para sistemas distribuídos, inspirado nos disjuntores elétricos. Assim como um disjuntor corta a energia quando detecta uma sobrecarga para proteger o circuito, o Circuit Breaker em software interrompe temporariamente as chamadas a um serviço que está falhando, evitando que falhas em cascata derrubem toda a aplicação.

Sem Circuit Breaker, quando um backend começa a falhar, o sistema continua enviando requisições para ele — consumindo recursos, aumentando latência e potencialmente causando timeout em cadeia. Com o Circuit Breaker, o sistema "aprende" que aquele backend está com problemas e para de enviar tráfego até que ele se recupere.

Os Três Estados do Circuit Breaker

O Circuit Breaker opera em três estados bem definidos:

Estado	Comportamento	Analogia
Closed (Fechado)	Tráfego flui normalmente para o backend. Falhas são contadas silenciosamente.	Disjuntor ligado — energia passa.
Open (Aberto)	Todas as requisições são imediatamente rejeitadas com 503 Service Unavailable + header Retry-After. Nenhuma chamada chega ao backend.	Disjuntor desligado — energia cortada para proteger o circuito.
Half-Open (Meio-aberto)	Após o trip duration expirar, o circuito permite uma requisição de teste. Se ela for bem-sucedida, volta para Closed. Se falhar, volta para Open.

A transição entre os estados segue este fluxo:

Por que isso importa para Azure OpenAI?

No contexto de IA generativa, uma chamada ao Azure OpenAI pode levar vários segundos. Se o backend está retornando erros (429 throttling, 500 internal error, 404 modelo não encontrado), cada tentativa desperdiça tempo precioso. O Circuit Breaker garante fail-fast: em vez de esperar 30 segundos por um timeout, o cliente recebe imediatamente um 503 com a informação de quando pode tentar novamente.

Configuração no APIM

Configuração do Circuit Breaker: 1 falha dispara abertura, status codes 400–599, trip duration de 1 minuto e Retry-After habilitado.

Os parâmetros configurados foram:

Parâmetro	Valor	Significado
Rule name	rulecb	Identificador da regra
Failure count	1	Basta 1 falha para abrir o circuito (agressivo, ideal para testes)
Failure interval	1 hora	Janela de tempo para contagem de falhas
Failure status code range	400-599	Qualquer resposta 4xx ou 5xx conta como falha
Failure error reason	BackendConnectionFailure	Tipo de erro que dispara o Circuit Breaker
Trip duration	1 minuto	Tempo que o circuito permanece aberto antes de tentar Half-Open
Check Retry-After header	True (Accept)	Respeita o header Retry-After do backend

Nota sobre o Failure Count: Em produção, um valor de 1 é muito agressivo — uma única falha transitória abriria o circuito. Valores entre 3 e 5 são mais comuns. Para este artigo, usamos 1 para facilitar a demonstração.

Comportamento Observado

Após falhas consecutivas, o APIM retorna 503 – Service Unavailable

O Circuit Breaker aparece como aberto no portal do Azure

O header Retry-After é incluído na resposta

4. Configurando as Políticas para usar o LB

Com backends, Load Balancer e Circuit Breaker configurados, o último passo é garantir que as políticas XML do APIM conectem tudo corretamente. Aqui estão os pontos que fazem toda a diferença entre uma configuração que funciona e uma que parece funcionar.

Ponto Importante #1 — Apontar para o Pool, não para o Backend

A política set-backend-service deve referenciar o Load Balancer Pool, e não um backend individual:

<set-backend-service id="apim-generated-policy" backend-id="LB01" />

Se você apontar diretamente para openapi01-openai-endpoint, perde todo o benefício do balanceamento e do failover automático.

Ponto Importante #2 — Buffer do Request Body

A política de retry deve usar forward-request com buffer-request-body="true". Sem isso, o body da requisição é consumido na primeira tentativa e não está disponível para retentativas:

Ponto Importante #3 — Retry balanceado pelo LB

Este é o ponto mais crítico e o que diferencia uma configuração robusta de uma ingênua. Se o set-backend-service estiver fora do bloco <retry>, o backend é selecionado uma única vez — e todas as retentativas vão para o mesmo endpoint. Se esse endpoint está falhando, todas as retentativas falham também.

A solução é colocar o set-backend-service dentro do <retry>:

Com essa configuração, a cada tentativa o Load Balancer é consultado novamente e pode rotear para um backend diferente. O resultado prático: se oiaws02 falha, a retentativa vai para oiaws01 automaticamente.

Explicação dos Elementos

Elemento	Descrição
<retry>	Define lógica de repetição (retry) para chamadas a serviços de backend
condition="@(context.Response.StatusCode == 404)"	Condição para acionar a repetição: resposta HTTP 404 (Not Found)
count="2"	Número máximo de tentativas adicionais (além da original)
interval="1"	Intervalo de 1 segundo entre as tentativas
first-fast-retry="true"	A primeira repetição é imediata, sem aguardar o intervalo
<forward-request />	Envia a requisição ao serviço de backend

5. Trace — Validação do Fluxo

onfiguração feita, é hora de validar. O Trace do APIM permite acompanhar passo a passo o que acontece com cada requisição — desde a entrada até a resposta final ao cliente. É a ferramenta definitiva para confirmar que o Load Balancer, o Circuit Breaker e o retry estão funcionando em conjunto.

No cenário de teste, o backend oiaws02 não possui o modelo o1 deployado, então retorna 404. O Trace mostra exatamente como o APIM lida com isso:

Backend selecionado no pool:

Backend '(, https://oiaws02.openai.azure.com/openai)' was selected in Backend pool 'LB01'.

Autenticação via Managed Identity:

Managed identity token is added to Authorization header.

Primeira tentativa — falha (oiaws02 não possui o modelo o1):

Request sent to https://oiaws02.openai.azure.com/openai/deployments/o1/chat/completions → Response: 404 Not Found

Retry com novo backend selecionado pelo LB:

Backend service URL was changed. oldBackendServiceUrl: https://oiaws02.openai.azure.com/openai newBackendServiceUrl: https://oiaws01.openai.azure.com/openai

Segunda tentativa — sucesso:

Request sent to https://oiaws01.openai.azure.com/openai/deployments/o1/chat/completions → Response: 200 OK

Resposta final ao cliente:

Response has been sent to the caller in full

O cliente recebeu a resposta com sucesso, sem saber que houve uma falha nos bastidores. Isso é resiliência transparente.

6. Events — Monitoramento do Circuit Breaker

Ter resiliência é essencial, mas saber quando ela está sendo acionada é igualmente importante. Se o Circuit Breaker está abrindo com frequência, pode indicar um problema que precisa de atenção — um backend degradado, um modelo removido, ou limites de throttling sendo atingidos repetidamente.

Captura de Eventos via Storage Queue

O APIM foi configurado para capturar eventos de abertura do Circuit Breaker e enviá-los para uma Storage Queue. Cada vez que um circuito abre, um evento é publicado com todos os detalhes relevantes.

Observação: Após essa configuração, a abertura do Circuit Breaker pode não aparecer mais no Trace, embora continue sendo registrada na fila.

Criação da Event Subscription no Event Grid com os tipos "Circuit Breaker Opened" e "Circuit Breaker Closed" selecionados para capturar eventos de abertura e fechamento do circuito.

Painel de Events do APIM mostrando 20 eventos publicados e entregues com sucesso à Storage Queue via subscription cbapim (Circuit Breaker Opened/Closed).

Exemplo de Evento

{ "id": "e5da5756-61b9-42cf-8097-f8a684f1b74c", "topic": "/subscriptions/.../resourceGroups/apimappgw/providers/Microsoft.ApiManagement/service/apimappgwws01", "subject": "/backends/openapi01-openai-endpoint/circuit-breaker/rules/cb01", "data": { "backendName": "openapi01-openai-endpoint", "circuitBreaker": { "rules": { "cb01": { "tripDuration": "00:00:15" } } } }, "eventType": "Microsoft.ApiManagement.CircuitBreaker.Opened", "dataVersion": "1.0", "metadataVersion": "1", "eventTime": "2025-08-14T15:41:30.948673Z" }

O evento nos diz exatamente: qual backend foi isolado (openapi01-openai-endpoint), qual regra foi violada (cb01), e por quanto tempo o circuito ficará aberto (15 segundos).

7. Export Events com Logic Apps → Elastic Observability

A Storage Queue resolve o problema de captura, mas para monitoramento em tempo real e dashboards operacionais, precisamos levar esses dados para uma plataforma de observabilidade. Neste caso, utilizamos o Elastic Observability.

Fluxo de Integração

O pipeline completo funciona assim:

Circuit Breaker abre → evento é publicado na Storage Queue
Logic App é acionado pelo trigger da fila
Logic App recupera a API Key no Key Vault (via Managed Identity — sem segredos hardcoded)
Logic App envia os dados via HTTP POST para o Elastic Observability

Exemplo de Chamada HTTP

POST https://apim-a5eaba.es.eastus.azure.elastic.cloud/apim/_doc Content-Type: application/json Authorization: ApiKey ...

Body: JSON do evento do Circuit Breaker.

Configuração no Elastic

Para receber e visualizar os eventos, é necessário:

Criar um índice (apim) para armazenar os documentos
Criar uma API Key com permissão de escrita no índice
Obter a URL do projeto Elastic Cloud
Criar uma View/Dashboard para visualizar os eventos de abertura do Circuit Breaker

Com esse pipeline completo, a equipe de operações consegue responder rapidamente a perguntas como: "Quantas vezes o circuito abriu nas últimas 24 horas?", "Qual backend está mais instável?", "Os problemas coincidem com horários de pico?".

Conclusão

A combinação de Load Balancer + Circuit Breaker + Retry inteligente no APIM transforma uma arquitetura frágil em uma arquitetura resiliente — onde falhas em backends individuais são tratadas de forma transparente, sem impacto para o cliente.

Os pontos-chave para levar:

Nunca exponha um único endpoint de Azure OpenAI diretamente — use o APIM como abstração
Managed Identity elimina o gerenciamento manual de segredos entre APIM e backends
O set-backend-service deve estar dentro do <retry> para que retentativas sejam distribuídas pelo Load Balancer
Circuit Breaker protege contra falhas em cascata — fail-fast é melhor que timeout lento
Observabilidade não é opcional — se o circuito está abrindo, você precisa saber

Referências

Uso de contextos no Entra ID

wdossantos — Thu, 23 Apr 2026 12:53:59 GMT

Visão Geral

Com a crescente necessidade de segurança adaptativa, o Microsoft Entra ID oferece recursos avançados para aplicar políticas dinâmicas de acesso. Em cenários corporativos, autenticação e autorização tradicionais, baseadas apenas em roles e claims estáticos, nem sempre são suficientes. Imagine que um usuário já está logado e possui permissão para acessar uma API, mas você precisa garantir que, para uma operação crítica como deletar um registro, ele esteja dentro da rede corporativa, em um dispositivo gerenciado ou tenha assinado um termo de confidencialidade. É exatamente isso que os contextos de autenticação do Microsoft Entra ID resolvem.

Neste artigo vou detalhar todo o processo, desde a habilitação do Continuous Access Evaluation (CAE), passando pela configuração dos contextos e das políticas de acesso condicional no portal do Entra ID, até a integração prática com uma aplicação .NET dividida em frontend web e API de backend. No código, veremos como o MSAL intercepta o fluxo, verifica se o token contém a claim acrs com o contexto exigido e, caso não contenha, dispara um challenge que leva o usuário de volta ao Entra ID para cumprir o requisito adicional. Se o contexto já estiver satisfeito, o fluxo é transparente para o usuário.

O objetivo é destacar a granularidade no controle de acesso, a estrutura de contexto, os desafios de implementação e potenciais aplicações práticas.

Diagrama de Arquitetura

1. Caso de Uso

Para exemplificar, utilizamos uma aplicação .NET simples, dividida em dois componentes:

API de backend, que expõe endpoints protegidos
Aplicação web frontend, que consome a API via tokens

Fluxo Básico

A aplicação web é protegida pelo Entra ID
Ao iniciar, o MSAL (SDK de identidade da Microsoft) verifica se o usuário está autenticado
Se não estiver, solicita a autenticação
Após autenticado, a aplicação armazena um token para consumir a API

O Diferencial

Não basta um token de acesso convencional para consumir um endpoint específico da API. É necessário um token com uma claim especial (acrs), contendo exatamente o valor do contexto esperado.

2. Configuração do Entra ID

App Registration e Contextos

O processo inicia com o registro das aplicações (cliente e API) no Entra ID, mantendo as etapas tradicionais de permissionamento e definição de escopos.

A novidade está na configuração de contextos, que são pares chave-valor criados no Entra ID e utilizados em políticas de acesso condicional.

Pré-requisito: Licença Entra ID P1 para uso de acesso condicional.

O contexto é configurado em uma aba específica dentro das políticas de acesso condicional.

Ao criar um novo contexto, define-se o nome, descrição e o ID sequencial (ex: c1). O checkbox "Publish to apps" torna o contexto disponível para as aplicações consumirem:

Estrutura e Limitações dos Contextos

Aspecto	Detalhe
Identificação	Número sequencial (ex: c1, c2, até c99)
Limite	Vinculado ao número máximo de regras de acesso condicional (195)
Composição	Nome + Descrição
Utilidade	Depende da implementação na aplicação

Aplicação Prática dos Contextos

O contexto permite granularidade adicional além das tradicionais roles e claims do token JWT:

Rede corporativa: restringir acesso a uma área apenas para usuários dentro da rede interna
Dispositivos gerenciados: exigir que o dispositivo esteja em compliance
Assinatura de termos: exigir ações adicionais (ex: NDA) antes do acesso a dados sensíveis, mesmo que o token permita o acesso

Por fim, o contexto é vinculado a uma política de acesso condicional. No exemplo abaixo, a policy "Teste - C10" associa o contexto "Teste WebApp" como target resource:

3. Implementação no Código

3.1 Configuração no Cliente (Startup.cs)

No processo de inicialização, utiliza-se o método AddMicrosoftIdentityWebAppAuthentication para configurar a autenticação, incluindo o parâmetro ClientCapabilities, que habilita o uso de contexto.

Além disso, é adicionado o handler MicrosoftIdentityConsentAndConditionalAccessHandler para gerenciar o fluxo de acesso condicional.

// Habilita autenticação com suporte a contexto e acesso condicional services.AddMicrosoftIdentityWebAppAuthentication(Configuration) .EnableTokenAcquisitionToCallDownstreamApi( Configuration.GetSection("TodoList:Scopes").Get<string[]>() ) .AddInMemoryTokenCaches(); // Handler para gerenciar challenge de acesso condicional services.AddScoped<MicrosoftIdentityConsentAndConditionalAccessHandler>();

3.2 Configuração (appsettings.json)

O ponto-chave é o ClientCapabilities: ["cp1"], que habilita o suporte a Continuous Access Evaluation:

{ "AzureAd": { "Instance": "https://login.microsoftonline.com/", "Domain": "cyber.meudominio.com.br", "TenantId": "...-8888-4400-8c9c-...", "ClientId": "...-e635-...-bb9f-...", "CallbackPath": "/signin-oidc", "SignedOutCallbackPath": "/signout-oidc", "ClientCapabilities": [ "cp1" ], "ClientSecret": "XHm8Q~6_rNy_ib-....~KbcvF" } }

A classe Configuration, passada para AddMicrosoftIdentityWebAppAuthentication, localiza e carrega automaticamente a seção AzureAd do arquivo de configuração.

3.3 Método Crítico: Validação do Contexto

No endpoint crítico (ex: deletar item), o código verifica se o token do usuário contém a claim acrs com o valor do contexto exigido:

// GET: TodoList/Delete/5 public async Task<ActionResult> DeleteItem(int id) { string requiredAuthContextId = "c10"; string acrsClaimType = "acrs"; // Construção do claimsChallenge var claimsChallengeObj = new { id_token = new { acrs = new { essential = true, value = requiredAuthContextId } } }; string claimsChallenge = System.Text.Json.JsonSerializer.Serialize(claimsChallengeObj); // Verifica se o usuário possui o claim necessário Claim acrsClaim = User.FindAll(acrsClaimType) .FirstOrDefault(x => x.Value == requiredAuthContextId); if (acrsClaim?.Value != requiredAuthContextId) { // Dispara challenge para cumprir o contexto exigido _consentHandler.ChallengeUser( new[] { "api://ce845259-3c67-43c1-9816-43f82f4d7704/ToDoList.Read", "api://ce845259-3c67-43c1-9816-43f82f4d7704/ToDoList.ReadWrite" }, claimsChallenge ); } try { var todo = await _downstreamApi.GetForUserAsync<Todo>( "TodoList", options => options.RelativePath = $"api/todolist/{id}"); if (todo == null) return NotFound(); return View(todo); } catch (Exception) { return RedirectToAction("Index"); } }

Lógica do Fluxo

Claim presente e válida: a operação é permitida normalmente
Claim ausente: o ChallengeUser() abre a tela do Entra ID para o usuário cumprir o requisito (ex: MFA, assinatura de termo)
Contexto já satisfeito: o fluxo é transparente para o usuário

4. Fluxo de Challenge e Resposta

Do lado da API (Backend)

Quando o contexto não é atendido, a API retorna:

401 Unauthorized com headers customizados
Informações sobre o contexto exigido no corpo/headers da resposta

Do lado do Cliente (Frontend)

O cliente captura exceções específicas (WebApiMsalUiRequiredException)
Extrai informações do header da resposta
Executa o fluxo de challenge conforme necessário
Após cumprido o requisito, o token é renovado com a claim acrs

5. Considerações Finais

O uso de contextos no Entra ID amplia as possibilidades de controle de acesso, permitindo requisitos dinâmicos e contextuais além das roles tradicionais
A implementação exige integração cuidadosa entre backend e frontend, além de testes para garantir o correto tratamento dos fluxos de challenge e resposta
A documentação limitada reforça a importância de compartilhar experiências e boas práticas para fomentar o uso do recurso
Requer licença Entra ID P1 para acesso condicional

Referências

Anonimização de Dados Sensíveis com a plataforma de IA do Azure

anaritak — Fri, 26 Dec 2025 17:51:22 GMT

A Lei Geral de Proteção de Dados (LGPD) estabelece padrões rigorosos para o tratamento de dados pessoais e sensíveis no Brasil. Dados pessoais incluem informações que identificam diretamente um indivíduo, como nome, endereço, telefone, CPF, RG e data de nascimento. Já os dados sensíveis abrangem categorias especiais, como origem racial ou étnica, crenças religiosas, opiniões políticas, dados de saúde ou genéticos, biometria, orientação sexual e filiação sindical. Esses dados exigem cuidados adicionais, pois impactam diretamente a privacidade e os direitos dos titulares.

No contexto do processamento e compartilhamento de documentos — especialmente em setores como o público e o médico — é essencial reconhecer e classificar corretamente esses tipos de dados. Documentos oficiais ou registros de saúde frequentemente contêm tanto informações pessoais quanto dados altamente sensíveis, tornando a anonimização uma necessidade prática além de uma exigência legal.

Proposta de Arquitetura

Para atender à demanda de anonimização de dados sensíveis em documentos, soluções modernas de inteligência artificial, como Azure Document Intelligence e Azure Language Service, oferecem capacidade para detectar e classificar automaticamente informações pessoais. Esses serviços aceleram o processo de proteção de dados, mas seus modelos genéricos podem não abranger totalmente todas as categorias previstas pela LGPD — especialmente aquelas mais complexas ou dependentes de contexto, como opiniões políticas, crenças religiosas ou informações específicas de saúde.

Um caso simbólico pode ilustrar esse cenário: imagine uma plataforma responsável pelo armazenamento e compartilhamento de documentos administrativos. Para garantir que conteúdos sensíveis possam ser divulgados sem violar a privacidade das pessoas citadas, é possível implementar uma solução de anonimização baseada em IA. Ao utilizar modelos genéricos dos serviços de linguagem do Azure, conseguimos cobrir aproximadamente metade das classes previstas na LGPD, mas essas já abrangem a maior parte das classes determinísticas da legislação.

Abaixo, a arquitetura sugerida é detalhada de forma segmentada:

Azure Document Intelligence

O Azure Document Intelligence compõe a primeira camada do processamento, responsável por extrair texto, estrutura e coordenadas dos elementos presentes nos documentos — como tabelas, formulários, assinaturas e marcações visuais. Essa leitura estrutural permite compreender não apenas o que está escrito, mas onde cada informação se encontra.

A escolha por esse serviço se deve à sua capacidade de fornecer OCR avançado, interpretar layouts complexos e identificar elementos adicionais, como códigos de barras e QR Codes, que muitas vezes carregam metadados sensíveis. Esse mapeamento preciso é essencial para aplicar anonimização diretamente nas regiões corretas, preservando a integridade visual do documento.

Azure Language Service — PII e Classificação

Nesta segunda etapa, o Azure Language Service é utilizado para identificar automaticamente informações pessoalmente identificáveis (PII), como nomes, endereços, dados de contato e números de documentos. O modelo analisa o conteúdo com foco semântico, classificando entidades conforme categorias previstas na LGPD.

A motivação para empregá-lo está em sua capacidade de fornecer uma base abrangente e pronta para uso, permitindo detectar rapidamente grande parte dos dados sensíveis encontrados em documentos reais. Isso reduz a necessidade de regras manuais e acelera o processo de anonimização.

Azure Language Service — Modelos Personalizados (Custom NER)

Embora os modelos genéricos atendam a boa parte dos cenários, documentos reais costumam conter entidades específicas do domínio — expressões próprias da instituição, cargos incomuns, nomes de sistemas internos, termos de contexto ou siglas não previstas pelo modelo padrão.

Para suprir essas lacunas, são usados modelos personalizados de Reconhecimento de Entidades Nomeadas (NER). Eles permitem treinar novas categorias sensíveis e adaptar o processamento à realidade da organização. A motivação principal é reduzir falsos positivos/negativos e garantir maior precisão nos casos de uso mais complexos.

Azure Computer Vision

Quando documentos incluem imagens, fotografias ou capturas de telas, a anonimização precisa ir além do texto. O Azure Computer Vision é utilizado para detectar rostos e outras características visuais que possam identificar indivíduos.

Sua inclusão no processamento permite aplicar desfocagem ou mascaramento diretamente nos elementos encontrados, garantindo proteção também em conteúdo multimídia. Isso se torna especialmente relevante em documentos digitalizados que podem conter retratos, crachás, assinaturas digitalizadas ou imagens que exponham a identidade de terceiros.

Orchestrator Python — Lógica de Anonimização Baseada em Coordenadas

A última camada da solução é desenvolvida em Python, responsável por orquestrar os serviços de IA e aplicar a anonimização final no documento. Com base nas coordenadas extraídas pelo Document Intelligence e nas entidades classificadas pelo Language Service, o componente Redaction realiza o mascaramento diretamente sobre a área correspondente.

A escolha pelo Python se justifica pela sua flexibilidade, ampla disponibilidade de bibliotecas para manipulação de PDFs e imagens, e facilidade para integrar diferentes serviços do Azure em um único fluxo. Além disso, permite criar filtros adicionais — como evitar mascarar nomes de organizações ou estruturas fixas — garantindo precisão e consistência no resultado final.

Recomendações

Veja o repositório de uma demonstração simplificada com arquivos fictícios: Repo

Se você deseja implantar essa solução, pode utilizar o código disponível no repositório e adaptá-lo aos seus filtros e regras específicas. A estratégia recomendada é empacotar a aplicação em contêineres para facilitar a escalabilidade e a integração com diferentes ambientes.

Além disso, é possível consumir os serviços do Azure diretamente via APIs, garantindo flexibilidade na arquitetura e integração com outras aplicações. Todas essas informações, incluindo exemplos e orientações detalhadas, estão disponíveis na documentação oficial dos serviços Azure.

Essa abordagem integrada garante que documentos públicos possam ser compartilhados de forma segura, respeitando a legislação e protegendo a privacidade das pessoas. A evolução para modelos personalizados representa um salto importante, permitindo identificar e anonimizar dados que hoje passam despercebidos pelos modelos padrão, elevando o nível de conformidade e confiança no tratamento de dados sensíveis.

Agradecimentos

Agradeço especialmente ao Gilberto Santos, meu colega Cloud Solution Architect Linkedin, pela generosidade em compartilhar sua expertise sobre os serviços do Azure e pelo apoio essencial no desenvolvimento desta arquitetura.

Também registro meu agradecimento ao Alexandre Teoi, Cloud Solution Architect Linkedin, pela revisão criteriosa e pelas contribuições valiosas para o aprimoramento deste artigo.

Alta Disponibilidade e Resiliência com App Gateway e Múltiplos APIMs: Uma Arquitetura Estratégica

wdossantos — Tue, 09 Sep 2025 18:54:23 GMT

Resiliência como Pilar do Azure Well-Architected Framework

A resiliência é um dos pilares fundamentais do WAF e desempenha papel crítico na construção de arquiteturas modernas em nuvem. Este artigo explora o design de alta disponibilidade (HA) utilizando a oferta Premium Tier do Azure API Management (APIM) em cenários multi-região ou mesmo intra-região, com foco na aplicação de Availability Zones — uma prática recomendada no pilar de Confiabilidade.

A configuração Premium permite que as regiões primária e secundária compartilhem a mesma instância de APIM. No entanto, dependendo dos requisitos de negócio e tolerância a falhas, pode ser estratégico operar com duas instâncias separadas, garantindo continuidade de serviço mesmo diante de falhas regionais ou em uma das instâncias. Essa abordagem está alinhada ao modelo de DR Ativo-Ativo, promovendo tolerância a falhas, escalabilidade horizontal e resiliência operacional, conforme descrito no modelo de maturidade de confiabilidade.

A imagem acima representa os componentes do APIM nas regiões primária e secundária. Em cenários com instâncias separadas, esses componentes também estariam presentes em cada região. Já em uma configuração com Availability Zones, os elementos podem escalar dentro da mesma região, conforme a demanda — prática que também se conecta ao pilar de excelência operacional , ao permitir automação e monitoramento contínuo.

O fluxo de comunicação entre a API e os serviços de backend pode ocorrer por rotas diretas ou por meio de balanceadores de carga, dependendo do caso de uso. Essa arquitetura inspirou uma solução personalizada para um de nossos clientes, que buscava alta disponibilidade com baixa latência, mesmo em cenários de falha regional.

Configuração do APIM como gateway de saída para o cluster de aplicações

Press enter or click to view image in full size

Em alguns casos, por questões de compliance, não é possível operar fora de um regions específica . Ainda assim, essa arquitetura já proporciona ganhos significativos mesmo dentro da mesma região, como maior resiliência, escalabilidade e eficiência operacional.

Visão Geral da Arquitetura

Componentes principais:

Usuário: Inicia a requisição.
WAF: Protege contra ameaças e ataques na borda.
AKS: Gerencia APIs e aplicações containerizadas.
App Gateway (AppGW): Roteia o tráfego para os APIMs.
APIM001 e APIM002: Instâncias do Azure API Management, com IPs distintos e potencialmente em regiões diferentes.
Sistemas legados (kubernets / VMS): Integração com sistemas on-premises.

Essa arquitetura é interessante, pois, neste caso de uso, o APIM atua como ponto de saída do cluster de aplicações — exatamente o caminho crítico que queremos proteger

Com duas instâncias de APIM atrás do AppGW, é possível:

Realizar manutenções planejadas em uma instância sem impactar os usuários.
Redirecionar o tráfego automaticamente para a instância saudável.
Garantir zero downtime, mesmo durante atualizações críticas.

Essa abordagem é especialmente útil em ambientes com alta exigência de SLA, como bancos, governo e telecom.

Testes Blue-Green com Segurança e Controle

A arquitetura permite implementar estratégias Blue-Green com facilidade:

Uma instância do APIM pode representar o ambiente “Blue” (produção atual).
A outra instância representa o ambiente “Green” (nova versão).
O AppGW pode direcionar parte do tráfego para o ambiente Green para testes controlados.
Após validação, o tráfego pode ser totalmente migrado para o Green, promovendo a nova versão com segurança.

Isso reduz riscos de regressão e permite deploys mais confiáveis

Redução de Riscos em Caminhos Críticos

Ao distribuir o tráfego entre dois APIMs:

Reduz-se o risco de ponto único de falha.
A arquitetura se torna mais resiliente a falhas regionais ou de serviço.
Em caso de falha de uma instância, o AppGW garante continuidade do serviço.

Essa redundância é essencial para caminhos críticos de negócio, como autenticação, transações financeiras ou integrações com sistemas legados.

Outros Benefícios Estratégicos

✅ Disaster Recovery Ativo-Ativo

As duas instâncias do APIM funcionam simultaneamente em modo ativo-ativo.
Em caso de falha em uma das instâncias, o tráfego é automaticamente redirecionado.
Reduz significativamente o RTO e assegura a continuidade dos serviços..

✅ Mitigação de Esgotamento de IPs

O uso de múltiplas instâncias permite distribuir o consumo de IPs.
Evita gargalos de rede e problemas de limitação de recursos.

✅ Escalabilidade Regional

A arquitetura possibilita escalabilidade horizontal simplificada.
Suporta o crescimento de demanda em diferentes regiões de forma eficiente.

Como configurar o APPGW para uma POC de balanceamento entre dois APIMs

O Azure Application Gateway é um balanceador de carga de camada 7 (HTTP/HTTPS) que permite gerenciar o tráfego de aplicações web com inteligência, segurança e escalabilidade. Ele opera com base em um conjunto de configurações como Listeners, Routing Rules, Backend Targets entre outras.

Além disso, o Application Gateway oferece recursos avançados como WAF (Web Application Firewall), SSL offloading, redirecionamento baseado em caminho e afinidade de sessão, tornando-o ideal para cenários que exigem alta disponibilidade e proteção contra ameaças web.

Press enter or click to view image in full size

📦 Descrição de cada componente do diagrama

Listener (porta 80): Detecta conexões de entrada na porta especificada (ex: 80 para HTTP). É o ponto inicial onde o tráfego chega ao gateway.
Routing Rule: Define como o tráfego será roteado com base em critérios como URL, cabeçalhos ou métodos. É o cérebro da decisão de encaminhamento.
Backend Targets: Especifica os destinos finais para o tráfego, como VMs, instâncias de App Service ou containers. 🔁 Relação com Backend Pools: 1 para N — uma regra pode apontar para vários destinos.
Backend Setting: Configurações aplicadas ao tráfego, como tempo de timeout, protocolo (HTTP/HTTPS), e afinidade de sessão. 🔁 Relação com Health Probes: 1 para 1 — cada configuração tem uma sonda associada.
Backend Pools: Agrupamento lógico dos destinos (targets). Permite distribuir carga entre múltiplas instâncias. 🔁 Relação com Backend Targets: 1 para N — um pool pode conter vários destinos.
Health Probes (path:/status-0123456789abcdef)
Verifica a saúde dos destinos usando um caminho específico. Se um destino estiver inativo, ele é automaticamente removido do balanceador.

Vamos apresentar algumas telas de configuração e destacar pontos de atenção no Application Gateway (AppGW).

Um detalhe importante que acabei não mencionando: à frente do Listener existe uma configuração de Frontend IP, que define se o IP do AppGW será público ou privado. Para facilitar os testes iniciais, recomendo começar com o Frontend IP público,alem disso mantenha o Listener configurado na porta 80. Isso evita complicações com certificados SSL durante os testes.

Observe a imagem abaixo: o Frontend IP está corretamente vinculado ao Listener1, como indicado. Essa associação é essencial para garantir que o tráfego seja direcionado corretamente, conforme a configuração do IP público ou privado definida no Frontend.

Press enter or click to view image in full size

O Listener1, configurado na porta 80, está associado à Rule1, que define como o tráfego será roteado para o backend correspondente.

Press enter or click to view image in full size

A Rule1 está associada às configurações de Backend Settings, que definem como o tráfego será encaminhado para os recursos de backend — incluindo o pool de servidores, o protocolo, a porta e os critérios de saúde.

Press enter or click to view image in full size

As Backend Settings do Application Gateway incluem configurações importantes, como “Pick host name from backend target” e a associação a um Custom Probe.

Por padrão, o AppGW encaminha ao backend o mesmo cabeçalho HTTP Host recebido do cliente. No entanto, se o serviço ou aplicação no backend exigir um valor específico para o cabeçalho Host, é possível sobrescrevê-lo utilizando essa configuração. Com isso, o Application Gateway passa a usar o host do backend para resolver o balanceamento e validar o probe de integridade, garantindo compatibilidade com serviços que dependem de hostname específico para funcionar corretamente.

Press enter or click to view image in full size

Perceba que o Health Probe também está vinculado às Backend Settings, e utiliza a configuração “Pick host name from backend settings”.

Essa associação é fundamental para garantir que o probe de integridade seja executado corretamente, especialmente em cenários onde o backend exige um cabeçalho Host específico. Ao ativar essa opção, o Application Gateway passa a usar o hostname do backend tanto para o roteamento quanto para a validação do probe, assegurando compatibilidade com serviços que dependem dessa configuração.

Press enter or click to view image in full size

Esse endereço /status-0123456789abcdef é o endereço de sondagem do apim (helth cehck) do APIM

Voltando à Rule1, podemos observar que ela também define o Backend Target, que neste caso aponta para o serviço de backend do APIM (Azure API Management).

Essa configuração é essencial para garantir que o tráfego roteado pelo Application Gateway seja direcionado corretamente ao endpoint do APIM, respeitando as regras de roteamento, cabeçalhos e probes definidos nas Backend Settings.

Press enter or click to view image in full size

Nos Backend Pools, temos o pool de backend do APIM, que contém duas instâncias do serviço Azure API Management. Essa configuração permite distribuir o tráfego entre as instâncias, garantindo alta disponibilidade e escalabilidade para os serviços expostos via AppGW.

Press enter or click to view image in full size

Do lado do APIM

Para observar o processo de balanceamento entre instâncias do APIM (por exemplo, APIM A e APIM B), podemos criar uma API de mock que responda de forma simples, identificando qual instância está respondendo.

Principais Objetos do APIM

Políticas: São regras aplicadas às requisições HTTP, permitindo manipulações como transformação de payloads, controle de acesso, limitação de chamadas (rate limiting), entre outras.
API: Representa um conjunto de operações agrupadas sob um único endpoint. Cada API pode conter múltiplas operações.
Operações: São as ações HTTP específicas, como os verbos GET, POST, PUT, DELETE, etc. Cada operação define o comportamento de uma rota dentro da API.

Como criar um mock no Azure API Management (APIM)

Adicionar uma nova API

Acesse o menu lateral e clique em “Add API”.
Selecione a opção para criar uma API manualmente.
Na caixa de diálogo exibida, preencha os dados necessários (nome, URL base, etc.).

eu criei uma APIA, com sufixo apim

Press enter or click to view image in full size

Definir o response da operação

Clique em “add operation” e preencha o verbo como get a url como /moq
Após criar a operação desejada, clique na aba “Responses”.
Clique em “Add response” e selecione o código 200.
Em Content type, escolha application/json.
No campo Sample, insira um JSON de exemplo para identificar a instância, como:

JSON

{
"name": "APIMA"
}

Press enter or click to view image in full size

Adicionar a política de mock

Vá para a aba “Design” da operação.
Na seção Inbound processing, clique em “Add policy”.
Selecione a política “Mock response”.

Verificação

Após salvar, o pipeline da requisição exibirá uma tarja amarela, indicando que o mock está ativo.

Press enter or click to view image in full size

Repita esse processo para a instância dois. Agora já podemos testar o balanceamento de carga pelo Application Gateway

Press enter or click to view image in full size

Sincronização das Instâncias com o API OPS

Conforme mencionado no início deste artigo, a arquitetura “by the book” foi projetada para utilizar o recurso nativo de multi-região do Azure API Management (APIM), o que elimina a necessidade de esforços adicionais para sincronizar configurações entre instâncias.

No entanto, ao optarmos por manter duas instâncias separadas na mesma região, com o objetivo de obter os benefícios citados anteriormente, passamos a ter o desafio de manter ambas sincronizadas — ou seja, com as mesmas APIs, endpoints e políticas.

Para atender a essa necessidade de sincronização, utilizaremos o API Ops, que automatiza o processo de publicação e atualização das configurações entre as instâncias, garantindo consistência e reduzindo o risco de divergências operacionais.

Press enter or click to view image in full size

Resumo do Fluxo de API Ops para Sincronização com o APIM

Press enter or click to view image in full size

Operadores de API executam o pipeline de extração para sincronizar o repositório Git com a instância do API Management, populando o repositório com os objetos no formato necessário.
Se houver alterações detectadas na instância do APIM, é criado um Pull Request (PR) para revisão. Após aprovação, os operadores fazem o merge das mudanças no repositório.
Desenvolvedores de API clonam o repositório, criam uma branch e definem as APIs usando especificações OpenAPI ou ferramentas de sua preferência.
Quando um desenvolvedor envia alterações para o repositório, um novo PR é gerado para revisão.
O PR pode ser aprovado automaticamente ou revisado manualmente, conforme o nível de controle exigido.
Após a aprovação e o merge, o pipeline de publicação implanta as alterações na instância do API Management.
Os operadores também podem criar ou modificar políticas, diagnósticos, produtos e outros objetos relevantes, e então comitar essas alterações.
Após o merge, o pipeline publica as mudanças usando o processo de definição de APIs.

Conclusão

A adoção de uma arquitetura com App Gateway à frente de múltiplos APIMs, integrada com Akamai WAF, Azure Functions, Key Vault e sistemas legados, oferece uma solução robusta, segura e altamente disponível. Essa abordagem não apenas melhora a experiência do usuário, mas também reduz riscos operacionais e facilita a evolução contínua da plataforma.

Referencias

AKS - Problemas de desempenho do NGINX Ingress Controller Gerenciado

ClaudioGodoy — Fri, 05 Sep 2025 13:44:38 GMT

O NGINX ingress controller gerenciado é um complemento de roteamento que permite direcionar tráfego HTTP e HTTPS para aplicações executando em um cluster Azure Kubernetes Service (AKS).

Em problemas relacionados à performance, o sistema de roteamento pode ser a causa raiz. Este artigo fornece um guia passo a passo para solucionar problemas de performance do NGINX ingress controller.

Pré-requisitos

Antes de começar, certifique-se de ter as seguintes ferramentas instaladas:

Kubernetes CLI (kubectl): Use o Azure CLI para instalar executando o comando az aks install-cli.

Sintomas Comuns

Sintoma	Descrição
Erros de Gateway HTTP	Códigos de erro como 502, 504 podem indicar um problema de exaustão do NGINX.
Alta Diferença no Tempo de Resposta	Diferença significativa entre o tempo de resposta do seu serviço e o tempo de resposta fim a fim. Existe uma latência comum adicionada pelo NGINX, mas quando é muito grande, pode indicar exaustão do NGINX.

Passo 1: Verifique o Comportamento do HPA

A razão mais comum para problemas de performance no NGINX é exaustão de CPU. Durante picos de carga no sistema, uma boa abordagem é observar o comportamento do HPA. Por padrão, o plugin de roteamento cria um namespace chamado app-routing-system.

Obtenha o nome do HPA:
```
 kubectl get hpa -n app-routing-system
```

Observe o comportamento do HPA:

 kubectl get hpa <HPA_NAME> -n app-routing-system -w

Avalie o resultado:

 $ kubectl get hpa <HPA_NAME> -n app-routing-system -w

 NAME    REFERENCE          TARGETS       MINPODS   MAXPODS   REPLICAS   AGE
 nginx   Deployment/nginx   cpu: 83%/70%   1         2         1          77m
 nginx   Deployment/nginx   cpu: 83%/70%   1         2         2          77m
 nginx   Deployment/nginx   cpu: 106%/70%        1         2         2          79m
 nginx   Deployment/nginx   cpu: 133%/70%        1         2         2          80m

A coluna TARGETS mostra o limite de CPU onde o HPA irá acionar o aumento de replicas. Você deve interpretar esse comportamento. Existem algumas possibilidades:

O HPA atingiu o número máximo de pods.
Não há nodes disponíveis para agendar os pods.

Passo 2: Procure por Pods em Estado Pending

Se no passo anterior você viu que o NGINX HPA não atingiu o número máximo de pods, o kube-scheduler pode estar tendo dificuldades para encontrar nodes disponíveis para agendar os pods do NGINX.

Obtenha Pods em Pending:

 kubectl get pod --field-selector=status.phase=Pending -n app-routing-system

Se houver pods em Pending, o cluster provavelmente está enfrentando um problema de exaustão de recursos. Nesse caso, consulte Solucionar erros do agendador de pods no Azure Kubernetes Service.

Passo 3: Verifique se Existem Limites Aplicados ao Deployment do NGINX

Qualquer configuração incorreta nos limites ou requests de recursos do NGINX pode fazer com que o HPA escale mais pods do que o necessário.

Descreva o Deployment do NGINX:

 kubectl describe deploy nginx -n app-routing-system

Verifique Requests e Limits:

 $ kubectl describe deploy nginx -n app-routing-system
 Name:                   nginx
 ....
 Selector:               app=nginx
 ....
 Pod Template:
 ....
 Containers:
 controller:
     ...
     Limits:
     ...
     Requests:
     ...

Solução

Por padrão, a versão atual do NGINX ingress controller não define limites para os pods do NGINX e define requests 500m de CPU, que é usado pelo HPA. Não é recomendado alterar esses valores diretamente na definição do deployment.

Se o seu HPA está atingindo o número máximo de pods e os requests e limits do deployment permanecem inalterados, você deve configurar o custom resource definition (CRD) chamado NginxIngressController.

Opções de Configuração

As opções de configuração abaixo impactam diretamente o comportamento do HPA:

Propriedade	Tipo	Descrição	Obrigatório	Padrão
`scaling`	objeto	Configuração para escalonamento do controller. Contém propriedades aninhadas.	Não	-
`maxReplicas`	inteiro	Limite superior de réplicas.	Não	100
`minReplicas`	inteiro	Limite inferior de réplicas.	Não	2
`threshold`	string	Limite de escalonamento definindo quão agressivo será o scaling. Opções: `rapid`, `steady`, `balanced`.	Não	balanced

Como Aplicar a Configuração

Siga os passos abaixo para aplicar a configuração:

Edite o CRD NginxIngressController:

 kubectl edit nginxingresscontroller -n app-routing-system

Adicione ou modifique a configuração de scaling:

 spec:
   scaling:
     maxReplicas: 10
     minReplicas: 2
     threshold: "balanced"

Salve e saia do editor para aplicar as alterações.
Verifique as alterações:
```
 kubectl get hpa -n app-routing-system
```

O HPA será atualizado automaticamente com base na nova configuração, e o NGINX ingress controller irá escalar conforme os parâmetros especificados.

Recursos adicionais

Anatomia de um serviço ASP.NET Core

ClaudioGodoy — Mon, 30 Jun 2025 00:39:17 GMT

O ecossistema do .NET é uma plataforma de desenvolvimento de software criada pela Microsoft. Ele inclui ferramentas, bibliotecas e frameworks para a criação de aplicações desktop, web, mobile, serviços e muito mais. Desde sua unificação, o .NET Core e o .NET Framework passaram a ser conhecidos apenas como .NET.

O .NET SDK (Software Development Kit) fornece as ferramentas necessárias para criar, compilar, depurar e publicar aplicações .NET. Ele inclui o compilador C#), bibliotecas de classes como ASP.NET Core e Entity Framework Core, além de utilitários como o MSBuild.

O ambiente de execução .NET (Common Language Runtime ou CLR) gerencia a execução de programas .NET, oferecendo serviços como gerenciamento de memória, coleta de lixo e controle de exceções.

Tipos de Aplicações .NET

Web API: Aplicações que fornecem serviços e endpoints RESTful para interação com clientes.
Razor com SSR (Server-Side Rendering): Ideal para aplicações que precisam de SEO e renderização eficiente.
Console Application: Útil para tarefas automatizadas e scripts.
MAUI (Multi-platform App UI): Permite o desenvolvimento de aplicativos multiplataforma.
Libraries (.NET Standard/Core Libraries): Conjuntos de código reutilizável para funcionalidades específicas.

ASP.NET Core WebAPI

Uma WebAPI segue o estilo arquitetural REST (Representational State Transfer), utilizando o protocolo HTTP para comunicação.

Protocolo HTTP: Define métodos como GET, POST, PUT e DELETE para manipulação de recursos.
REST API: Utiliza URIs para identificar recursos e métodos HTTP para operações CRUD.
Modelo de Richardson: Estabelece níveis de maturidade em APIs REST.

O foco principal do artigo está na WebAPI, devido à sua relevância na criação de serviços modernos.

Demo

Para criar uma webapi, com o dotnet sdk instalado, rode o comando:

dotnet new webapi -n MinhaApi

Após executar o comando, será gerada uma estrutura básica de projeto contendo:

Controllers: Arquivos para definir os endpoints da API.
Program.cs: Configuração inicial da aplicação.
appsettings.json: Arquivo de configuração.

Você pode iniciar o servidor com:

cd MinhaApi

dotnet run

Ciclo de vida de uma requisição HTTP em aplicações ASP.NET Core

Server

Uma aplicação ASP.NET Core é executada com uma implementação de servidor HTTP in-process. Esse servidor escuta por requisições HTTP e as disponibiliza para a aplicação através do HttpContext.

As responsabilidades do servidor incluem:

Escutar em uma porta específica para receber solicitações HTTP.
Processar as requisições e encaminhá-las para os middlewares configurados.

Middlewares

Os middlewares são componentes que processam requisições e respostas. Eles podem:

Autenticar usuários.
Registrar logs.
Manipular erros.

Exemplo de configuração de middleware:

app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
    endpoints.MapControllers();
});

Controllers

Os controllers são responsáveis por definir os endpoints da API. Um exemplo básico:

[ApiController]
[Route("api/[controller]")]
public class MinhaController : ControllerBase
{
    [HttpGet]
    public IActionResult Get()
    {
        return Ok("Hello World");
    }
}

Resumo

O ciclo de vida de uma requisição HTTP envolve o servidor, middlewares e controllers, garantindo que cada etapa seja processada de forma eficiente e escalável.

Conclusão

O ASP.NET Core é uma plataforma poderosa e flexível que permite o desenvolvimento de aplicações modernas, robustas e escaláveis. Desde sua arquitetura modular com middlewares até a configuração do pipeline de requisições, ele fornece ferramentas essenciais para criar soluções otimizadas e adaptadas a diferentes necessidades, seja para web, APIs RESTful ou sistemas distribuídos.

Ao longo deste artigo, exploramos desde os fundamentos do .NET e a ampla gama de tipos de aplicativos que podem ser criados, até os detalhes do ciclo de vida de uma requisição HTTP e a importância dos servidores Kestrel e HTTP.sys. Com uma compreensão clara do pipeline de requisições e dos middlewares, é possível projetar sistemas que não apenas atendem aos requisitos técnicos, mas também oferecem excelente desempenho e uma experiência de usuário consistente.

Dominar o ecossistema do ASP.NET Core é essencial para desenvolvedores que desejam se destacar no desenvolvimento de serviços e aplicações web de alto desempenho.

Participe da 2ª edição do GitHub Copilot Global Bootcamp

cynthiazanoni — Fri, 06 Jun 2025 14:19:57 GMT

O GitHub Copilot Global Bootcamp começou em fevereiro como uma jornada totalmente virtual de aprendizado — e foi um sucesso. Mais de 60 mil desenvolvedores participaram da primeira edição, em vários idiomas e regiões. Agora, estamos empolgados em lançar a segunda edição — maior e melhor — com workshops virtuais e presenciais, organizados por comunidades de tecnologia ao redor do mundo.

Essa nova edição chega logo após os anúncios do Microsoft Build 2025, onde as equipes do GitHub e do Visual Studio Code revelaram novidades empolgantes:

A extensão GitHub Copilot Chat será open source, reforçando a transparência e a colaboração.
A IA está sendo profundamente integrada ao Visual Studio Code, que agora está evoluindo para um editor de IA de código aberto.
Novas APIs e ferramentas estão tornando mais fácil do que nunca construir com IA e LLMs.

Este bootcamp é a sua oportunidade de explorar essas novas ferramentas, entender como usar o GitHub Copilot de forma eficaz e fazer parte da crescente conversa global sobre IA no desenvolvimento de software.

👩‍💻 Quem pode participar?

Seja você um(a) desenvolvedor(a) iniciante, estudante ou profissional experiente em tecnologia, este bootcamp foi feito para você. Você aprenderá casos de uso práticos do GitHub Copilot e como aumentar sua produtividade usando IA — em um formato acessível e prático.

Participe da edição virtual

Não importa onde você esteja, é possível participar online e aprender com a gente:

Português (Brasil – UTC -3)

24 de junho, 19h: Boas práticas para dominar o GitHub Copilot Chat
25 de junho, 19h: Integrações práticas com MCP Servers no VS Code e GitHub Copilot

Aprenda na sua cidade!

Estamos em parceria com comunidades locais de desenvolvedores para levar workshops presenciais a diversas cidades ao redor do mundo.

Sessões presenciais confirmadas no Brasil:

Data	Cidade	Inscrições
17 de Junho	Brasília, Brasil	Registre-se agora!
17 de Junho	Pato de Minas, Brasil	Registre-se agora!
21 de Junho	Mogi das Cruzes, Brasil	Registre-se agora!
26 de Junho	Recife, Brasil	Registre-se agora!
27 de Junho	Rio de Janeiro, Brasil	Registre-se agora!

O Microsoft Applied Skills é um programa de credenciamento criado para validar sua capacidade de realizar tarefas técnicas específicas do mundo real. Diferente das certificações tradicionais que costumam abranger cargos amplos, o Applied Skills foca em habilidades práticas e cenários reais, diretamente aplicáveis a desafios de negócios.

E a melhor parte? É totalmente gratuito!
Você demonstra suas habilidades por meio de avaliações interativas, baseadas em tarefas, em um ambiente simulado — sem perguntas de múltipla escolha, apenas trabalho real.

Uma das adições mais recentes é o Applied Skill do GitHub Copilot, que comprova sua habilidade de aproveitar a IA para aumentar a produtividade no desenvolvimento de software e melhorar a qualidade do código:

Acelere o desenvolvimento de aplicativos usando o GitHub Copilot.

Crie seu Primeiro Agente de IA com JavaScript e Azure AI Agent Service!

Glaucia_Lemos — Wed, 07 May 2025 17:37:50 GMT

Introdução: A Era dos Agentes de IA em JavaScript

Durante o AI Agents Hackathon, uma das sessões mais aguardadas foi apresentada por Wassim Chegham, que é Senior AI Developer Advocate em JavaScript na Microsoft. O tema? "Como Criar seu Primeiro Agente de IA com JavaScript e Azure AI Agent Service?" - uma ferramenta poderosa e pensada para desenvolvedores modernos que desejam criar aplicações AI-first com segurança, escabilidade e produtividade.

E, nesse artigo, vamos explorar os principais pontos abordados na sessão, com um foco especial em como você pode criar seu próprio agente de IA utilizando JavaScript e o Azure AI Agent Service.

A proposta do vídeo é clara: mostrar o passo a passo de como qualquer pessoa pode criar agentes de IA com JavaScript e TypeScript, utilizando Azure AI Foundry, e explicar todos os conceitos essenciais para dominar esse novo paradigma de desenvolvimento.

Se você perdeu a sessão, não se preocupe! Você pode assistir a gravação:

O que são Agentes de IA?

Wassim inicia a sessão com um panorama histórico: desde os chatbots tradicionais até os agentes inteligentes e autônomos que conhecemos hoje. Ele destacou:

Agentes baseados em LLMs (Large Language Models) que entendem a linguagem natural.
Agentes com ferramentas (tools) que executam ações no mundo real, como chamadas de API, buscas, execução de código etc.
Sistemas multiagentes, que coordenam vários agentes para resolver tarefas complexas.

O diferencial do Azure AI Agent Service é simplificar tudo isso, oferecendo uma plataforma gerenciada que cuida da orquestração, segurança, rastreamento e execução dos agentes.

Arquitetura de Soluções com Azure AI Agent Service

Durante a sessão, Wassim apresentou uma visão clara da arquitetura típica de uma aplicação de agente de IA desenvolvida com JavaScript. Ele explicou que, embora seja possível ter uma interface gráfica (FrontEnd) usando frameworks como Angular ou React, isso não é obrigatório - a aplicação pode muito bem funcionar num terminal, como foi o caso das demonstrações feitas ao vivo.

No BackEnd, o foco recai sobre o uso de Node.js, que pode ser combinado com frameworks como Express.js ou Fastify para expor APIs que comunicam com os agentes. Essa camada de API atua como ponte entre o usuário e a lógica do agente, coordenando mensagens, execuções e chamadas de ferramentas.

O próprio agente é criado e gerenciado com o SDK azure/ai-projects, que fornece uma API simples e direta para registrar agentes, definir instruções, anexar ferramentas e controlar execuções. Wassim destacou o quanto essa abordagem reduz a complexidade em comparação a outros frameworks de agentes, que exigem configuração manual de estado, orquestração e controle de contexto.

Além disso, há uma camada de ferramentas integradas ao serviço que ampliam significamente as capacidades do agente. São elas:

Code Interpreter: para execução de código Python em sandbox
Function Calling: para chamadas de funções definidas pelo usuário
Azure AI Search: para buscas vetoriais e RAG (Retrieval-Augmented Generation)
Bing Search: para grounding com dados em tempo real

Todas essas ferramentas são disponibilizadas de forma plug-and-play pela infraestrutura do Azure AI Agent Service.

Toda essa arquitetura é gerenciada por uma instância do Azure AI Foundry, que centraliza o controle de modelos, ferramentas, conexões e dados, proporcionando uma base robusta, segura e escalável para criar aplicações AI-first. Wassim fez questão de frisar que o agente é o verdadeiro "cérebro" da aplicação - recebendo instruções, raciocionando sobre elas e coordenando a execução de tarefas com auxílio de ferramentas externas, tudo isso com o poucos comandos em JavaScript.

Criando seu primeiro agente: Hands-on com JavaScript

Durante a demonstração prática, Wassim conduz os participantes por todas as etapas necessárias para criar um agente de IA funcional com JavaScript, utilizando o Azure AI Agent Service. Ele começa destacando que todo o código utilizado está disponível publicamente num repositório no GitHub, o que permite que qualquer pessoa possa clonar, rodar e adaptar os exemplos para seus próprios projetos.

> Link do repositório: Azure AI Agent Service - Demonstration

A primeira etapa envolve a instalação dos pacotes essenciais. O principal deles é o SDK azure/ai-projects (pacote npm - aqui), responsável por toda a interação com o serviço de agentes. Também é necessário instalar o azure/identity, que permite autenticar de forma segura com as credenciais da Azure sem precisar lidar com chaves ou tokens diretamente — utilizando, por exemplo, o DefaultAzureCredential.

Após configurar o ambiente com as dependências, Wassim mostra como criar uma instância do cliente de agente a partir de uma string de conexão obtida no portal do Azure Foundry. Essa string é armazenada em um arquivo .env, e permite que o código se conecte de forma segura ao serviço para criar e gerenciar agentes.

Com o cliente em mãos, o próximo passo é criar o agente propriamente dito. Para isso, é necessário definir o nome, o modelo de linguagem a ser usado (como o GPT-4) e fornecer instruções claras sobre o comportamento desejado para o agente — seja para realizar cálculos, responder perguntas, interpretar dados ou interagir com ferramentas externas.

Na sequência, Wassim introduz o conceito de thread, que funciona como um espaço de conversa entre o agente e o usuário. É nesse thread que as mensagens são armazenadas, as execuções são iniciadas e o histórico de interações é mantido. Ele mostra como criar um thread, enviar uma mensagem e iniciar uma run, ou seja, uma execução do agente a partir da mensagem fornecida.

A sessão então avança para demonstrar o uso de ferramentas. No primeiro exemplo, o agente resolve uma equação simples apenas com seu conhecimento interno, sem recorrer a ferramentas externas — um exemplo clássico para mostrar como o modelo pode raciocinar com base nas instruções fornecidas. Em seguida, Wassim mostra como ativar uma chamada de função personalizada: o agente acessa uma função que retorna o uso da CPU da máquina local, demonstrando a capacidade de executar ações no ambiente do usuário.

Outro exemplo impressionante é o uso do Code Interpreter, uma ferramenta que permite executar código Python remotamente e com segurança. Wassim fornece um arquivo CSV contendo dados de vendas de carros, e o agente não só processa os dados, como também gera visualizações gráficas em tempo real.

Além disso, ele demonstra como o agente pode utilizar o Bing Grounding para buscar informações atualizadas diretamente da internet, como cotações do mercado de ações. E, por fim, mostra a integração com o Azure AI Search, onde um índice vetorial previamente carregado com informações sobre planos de saúde é consultado para responder perguntas específicas, com direito a citações precisas da fonte utilizada — um ótimo exemplo do padrão RAG (Retrieval-Augmented Generation) em ação.

Esses exemplos mostram que, mesmo com poucos comandos em JavaScript, é possível criar agentes sofisticados, capazes de interagir com dados, ferramentas e usuários de maneira fluida, segura e produtiva.

Entendendo a mecânica interna: Como um agente funciona?

Wassim explica os conceitos fundamentais do ciclo de vida de um agente:

Agent: configurado com modelo e instruções.
Thread: representa a conversa (contexto).
Run: execução de uma tarefa.
Run Steps: etapas da execução.
Tools: definidas com schemas e acionadas conforme necessário.
Events: eventos emitidos durante a execução (streaming, tool-call, resposta, erro, etc).

Além disso, ele demonstra um projeto pessoal: uma ferramenta de tracing visual para acompanhar em tempo real cada etapa do agente, o que facilita o entendimento e o debug.

Um pouco sobre as tecnologias utilizadas no projeto

Para quem está curioso sobre as tecnologias utilizadas no projeto, Wassim fez questão de destacar algumas delas:

📦 SDK utilizado
- azure/ai-projects@2.0.0-beta.4
- azure/identity para autenticação com credenciais seguras.
🔧 Ferramentas integradas
- Function Calling: executa funções com base na entrada do LLM.
- Code Interpreter: executa código Python remotamente com segurança.
- Azure AI Search: busca vetorial e full-text com RAG.
- Bing Search Grounding: informações em tempo real da web.
- File Search (em breve): busca em arquivos carregados.
⚙️ Segurança e compliance
- Autenticação sem chaves (keyless)
- Private Networking (VNet)
- Content Filtering
- Tracing e logs para evitar alucinações

Conclusão: O Futuro dos Agentes de IA com JavaScript

A sessão de Wassim Chegham no AI Agents Hackathon foi uma verdadeira aula sobre como criar agentes de IA com JavaScript e Azure AI Agent Service. Ele não só apresentou os conceitos fundamentais, mas também mostrou na prática como é fácil e rápido desenvolver aplicações inteligentes utilizando essa nova abordagem.

Novamente se você perdeu a sessão, não se preocupe! Você pode assistir a gravação aqui.

E, claro , não deixe de conferir o repositório no GitHub com todos os exemplos e códigos utilizados durante a apresentação: Azure AI Agent Service - Demonstration.

E, no final, Wassim deixou uma mensagem clara: o futuro dos agentes de IA é promissor, e com as ferramentas certas, qualquer desenvolvedor pode criar soluções inovadoras e impactantes. Então, não perca tempo! Comece a explorar o Azure AI Agent Service e crie seu próprio agente de IA hoje mesmo!

Links úteis

Azure AI Agent Service: Documentação oficial do serviço de agentes de IA da Azure.
Azure AI Foundry: Plataforma para criar e gerenciar agentes de IA.
Azure AI Agent Service - Demonstration: Repositório GitHub com exemplos e códigos utilizados na sessão.
AI Agents Hackathon: Evento que reuniu desenvolvedores para explorar o potencial dos agentes de IA.
Wassim Chegham: LinkedIn do apresentador da sessão.
Azure AI Foundry - Getting Started: Guia para começar a usar o Azure AI Foundry.
Azure AI Agent Service - Quickstart: Tutorial rápido para criar seu primeiro agente de IA.
Azure AI Agent Service - Tools: Documentação sobre as ferramentas disponíveis no serviço de agentes de IA.
Azure AI Agent Service - Function Calling: Documentação sobre chamadas de função no serviço de agentes de IA.
Azure AI Agent Service - Code Interpreter: Documentação sobre o interpretador de código no serviço de agentes de IA.
Azure AI Agent Service - Azure AI Search: Documentação sobre o Azure AI Search no serviço de agentes de IA.
Azure AI Agent Service - Bing Search: Documentação sobre o Bing Search no serviço de agentes de IA.

Migração de Aplicações Full Framework para Azure AKS e .NET Core

wdossantos — Mon, 28 Apr 2025 12:18:09 GMT

Criando e Abrindo um projeto 4.7.2

Vou criar o projeto no Visual Studio 2015, usando a versão FULL Framework .NET 4.7 escolhi o template de uma aplicação ASP.NET Web Application. Este é um projeto pequeno, desses que já nascem prontos, vai servir bem para testar as ferramentas de migração.

Depois de criado o projeto, e é importante habilitar essa versão .NET Core no Visual Studio 2022, pois precisaremos abrir o projeto nessa IDE para usar as extensões. Caso você tenha algum projeto pronto em uma versão mais antiga do dotnet então basta usá-lo

Depois de ter o projeto que vamos migrar, precisei instar o dotnet-appcat conforme essa doc Azure Migrate application and code assessment for .NET — Azure Migrate | Microsoft Learn

A documentação pende a instalando dessa extensão no visual studio Azure Migrate application and code assessment — Visual Studio Marketplace depois disso podemos abri o projeto pelo Visual Studio 2022 e já e vamos encontrar a opção re-plataform to Azure clicando com botão direito no projeto ou na solution.

Se escolhermos clicar na solution o item re-plataform to Azure disponibilizara a opção new report

Então vamos escolher para qual o tipo de computação a aplicação vai ser migrada

E como escolhemos a solution, agora vamos selecionar os projetos que queremos analisar

Um relatório com as issues será apresentado

entramos na issue e podemos ver a opção de perguntar para o copilot

Resposta do copilot para um issue especifica

E é isso basta ir resolvendo as issues, com essa ferramenta você pode verificar o código-fonte, configurações e binários da sua aplicação para encontrar oportunidades de migração para o Azure. Ele vai ajudar a identificar problemas ao mover sua aplicação para o Azure e melhora o desempenho, escalabilidade e segurança, sugerindo soluções modernas e nativas da nuvem.

NET Upgrade Assistant

Agora vamos pensar na migração do código, antigamente eu utilizava um cara chamado Portability Analyzer O .NET Portability Analyzer — .NET — .NET | Microsoft Learn, mas ele foi descontinuado e no lugar agora temos o Assistente de Atualização do .NET

Vou escolher um projeto por vez, clicando com o botão direito sobre o projeto e selecionando a opção 'update'. Esse método, em vez de gerar um relatório com as issues, tenta uma conversão direta de código. Na maioria das vezes, ele apenas faz o retarget, mas mesmo assim ajuda

No caso de um projeto WEB, a melhor opção é criar um novo projeto, pois ele vai criar uma espécie de proxy para permitir a migração paralela dos controllers

Selecionar o framework para 8

O assistente vai criar o projeto .net core, mas apenas uma casca, sem ter migrado ó código de fato

A partir disso, precisamos voltar ao projeto original onde começamos a migração e clicar novamente em 'update' usando o botão direito sobre esse projeto. Então, será possível migrar controller por controller. Cada controller migrada leva consigo suas dependência

Escolher a solution

Também podemos escolher a solution que contém vários projetos. Nesse caso, vou clicar na solution e não no projeto. Veja que agora, em vez de converter, ele me dá a opção de criar um relatório.

e então ele analisa projeto por projeto e gera as issues para serem corrigidas

aqui também consegui pedir ajuda do copilot paras as issues, e assim fica muito mais prático do que o Portability Analyzer

O Assistente de Atualização do .NET ajuda a atualizar projetos para versões mais recentes do .NET e analisa seu código para detectar e corrigir possíveis incompatibilidades. Um foco da ferramenta é ajudar a migrar um projeto do .NET Framework, .NET Core ou .NET para a versão mais recente do .NET. Você usa a extensão ou a ferramenta para atualizar projetos inteiros do .NET ou algum aspecto do projeto, como a migração de um arquivo de configuração de um tipo mais antigo para um tipo mais recente.

Podemos utilizar a CLI

upgrade-assistant --help

para iniciar o assistente use o comando

upgrade-assistant upgrade

Script para fazer vários projetos

upgrade-assistant upgrade# Defina o diretório raiz $rootDir = "..." $destDir = "..." # Obtenha todos os arquivos .csproj no diretório raiz e subdiretórios $csprojFiles = Get-ChildItem -Path $rootDir -Recurse -Filter *.csproj # Execute o comando upgrade-assistant para cada arquivo .csproj foreach ($file in $csprojFiles) { Write-Host "Executando upgrade-assistant para $($file.FullName)" Start-Process -FilePath "upgrade-assistant" -ArgumentList "upgrade $($file.FullName) --operation Inplace --targetFramework net8.0 --destination ${destDir} " -Wait }

Referência

Destaques do VS Code Live: Agent Mode Day

cynthiazanoni — Tue, 22 Apr 2025 19:04:13 GMT

🎙️ Palestrantes: Olivia McVicker, Cassidy Williams, Burke Holland, Harald Kirschner, Toby Padilla, Rob Lourens, Tim Rogers, James Montemagno, Don Jayamanne, Brigit Murtaugh, Chris Harrison.

O que é o Agent Mode?

O Agent Mode no VS Code representa um avanço além da tradicional sugestão de código por IA. Em vez de apenas sugerir trechos de código, o Agent Mode permite que a IA:

Escreva, edite e itere sobre o código
Execute comandos no terminal de forma autônoma
Corrija seus próprios erros durante o fluxo de trabalho
Interaja com ferramentas externas, APIs e serviços

Isso cria um parceiro de codificação mais dinâmico e “agente”, capaz de automatizar tarefas complexas, reduzir intervenções manuais e manter o desenvolvedor no fluxo. O Agent Mode está disponível diretamente no VS Code e se integra perfeitamente ao GitHub Copilot, tornando recursos avançados de IA acessíveis a desenvolvedores de todos os níveis.

1. Model Context Protocol (MCP)

O MCP é um protocolo aberto que padroniza como aplicações fornecem contexto para Modelos de Linguagem de Grande Escala (LLMs). Ele serve como uma ponte, permitindo que agentes de IA no VS Code se conectem de forma segura a um vasto ecossistema de ferramentas, APIs e recursos internos — muito além do que está disponível nativamente.

Principais pontos sobre o MCP:

Abordagem de ecossistema: permite conectar Copilot e outros agentes a tudo que for necessário — documentação interna, bancos de dados, ferramentas de design como Figma, etc.
Aberto e extensível: qualquer pessoa pode criar e compartilhar novas integrações, com milhares de servidores MCP já disponíveis.
Encadeamento de ferramentas: servidores MCP podem ser combinados, permitindo que a IA automatize fluxos de trabalho que envolvem múltiplas ferramentas.
Seguro e em evolução: o protocolo está evoluindo para suportar autenticação mais segura e facilitar a descoberta e instalação de integrações.

2. Next Edit Suggestions (NES)

O Next Edit Suggestions (NES) é um recurso projetado para aprimorar a experiência de edição, oferecendo recomendações contextuais para mudanças no código. O NES auxilia desenvolvedores sugerindo edições relevantes com base no contexto atual, apoiando tarefas como refatoração, correção de bugs e adição de funcionalidades. Ele permite aceitar, desfazer ou iterar rapidamente sobre mudanças sugeridas pela IA, mantendo o controle total sobre o código.

3. Bring Your Own Key (BYOK): Integração de Modelos de IA Personalizados

O BYOK permite que usuários conectem suas próprias chaves de API para modelos de IA personalizados, incluindo OpenAI, Anthropic ou até modelos locais. Com o BYOK, desenvolvedores podem escolher entre vários modelos, integrar soluções locais ou em nuvem por motivos de privacidade, custo ou desempenho, e adaptar a experiência da IA às suas necessidades específicas.

4. O Futuro Agente

Uma prévia do “Project Padawan” mostrou que fluxos de trabalho agentes poderão rodar de forma assíncrona na nuvem. Será possível delegar tarefas ao Copilot (como resolver issues do GitHub), que criará pull requests, executará testes e iterará sobre feedbacks de forma autônoma, enquanto o desenvolvedor foca em outras atividades.

GitHub Copilot Skills Challenge

Quer aprender e experimentar o Agent Mode do GitHub Copilot enquanto conquista um Selo Digital? Participe do GitHub Copilot Skills Challenge — uma experiência prática de aprendizado no Microsoft Learn, onde você construirá um aplicativo Python usando o Agent Mode por meio de um tutorial guiado. Complete o desafio até 30 de abril de 2025 para ganhar seu selo!

Confira as regras oficiais: https://aka.ms/csc/terms
Inscreva-se no Desafio: https://aka.ms/csc/githubcopilot
Solicite seu selo em: https://aka.ms/getyourbadge

Como começar

Ative o Agent Mode — disponível nas versões estável e insiders do VS Code — para experimentar esses recursos avançados de IA. Explore integrações MCP navegando pela lista de servidores ou criando o seu próprio com os SDKs disponíveis.

Quer ver essas funcionalidades em ação? Assista ao stream completo para demonstrações ao vivo, dicas de especialistas e marque a data para o próximo episódio da nossa série VS Code Live: https://aka.ms/VSCode/Live

Happy coding!

Modo Agente disponível para todos os usuários do VS Code e com suporte a MCP

cynthiazanoni — Mon, 07 Apr 2025 21:17:34 GMT

O Modo Agente está sendo lançado para todos os usuários do VS Code!

O agente atua como um programador autônomo que realiza tarefas de codificação em várias etapas sob seu comando, como analisar sua base de código, propor edições de arquivos e executar comandos no terminal. Ele responde a erros de compilação e lint, monitora a saída do terminal e corrige automaticamente em um loop até que a tarefa seja concluída.

O agente também pode usar ferramentas contribuídas, permitindo que ele interaja com servidores MCP externos ou extensões do VS Code para realizar uma ampla variedade de tarefas.

Disponível para todos os usuários

Abra a visualização de Chat, faça login no GitHub, configure chat.agent.enabled nas suas configurações e selecione Agente no menu suspenso do modo de Chat. Se você não vir a configuração, certifique-se de recarregar o VS Code após atualizar para a versão mais recente. Nas próximas semanas, estamos lançando isso por padrão para todos - nenhuma configuração será necessária.

O modo Agente é ótimo para cenários onde:

Sua tarefa envolve várias etapas. O agente edita o código, executa comandos no terminal, monitora erros e itera para resolver quaisquer problemas que surgirem.
Você não tem certeza sobre o escopo das mudanças. O agente determina automaticamente os arquivos e o contexto relevantes.
Sua tarefa requer interação com aplicativos ou dados externos. O agente se integra com servidores MCP e extensões do VS Code.

Por outro lado, use o modo de edição quando a tarefa tiver um escopo bem definido, você quiser uma resposta rápida ou quiser um controle mais preciso sobre o número de solicitações ao LLM.

Criamos uma experiência de chat unificada, combinando as visualizações de Chat e Edições, que traz benefícios como histórico de sessões, mover o chat para uma janela separada e simplificação da visualização do Conjunto de Trabalho. Tudo isso agora também está disponível no modo Agente.

Continuamos a receber um feedback fantástico dos usuários (por favor, continuem enviando!), o que inspirou muitas das melhorias que fizemos. Mais notavelmente:

A ação de desfazer agora reverte as mudanças até a última chamada da ferramenta de edição de arquivos.
Suporte para múltiplas sessões de agente no mesmo workspace (melhor quando as sessões de edição não modificam os mesmos arquivos).
O agente agora pode criar e editar notebooks.
A capacidade de aprovar automaticamente chamadas de ferramentas (aprovação automática de terminal chegando em abril).
Uma série de melhorias na qualidade de vida e correções de bugs.

Tanto as experiências de perguntar quanto de editar estão evoluindo para uma arquitetura que, como o agente, utiliza ferramentas. Estamos fazendo essa mudança para unificar os modos de perguntar/editar/agente para serem todos agenticos, com o objetivo de suavizar a experiência geral do usuário. Isso permite que o modo de edição use a ferramenta de edição de arquivos para melhorar a velocidade, e os modos de edição e pergunta usem #codebase, uma busca agentica na base de código. Consequentemente, modelos de linguagem sem suporte para chamadas de ferramentas não estarão mais disponíveis no modo de edição.

Extensível: Servidores MCP e Extensões do VS Code

Assim como as extensões do VS Code permitem que você personalize seus fluxos de trabalho específicos, a extensibilidade do agente permite que você adapte o agente às suas necessidades. Com a extensibilidade, o agente pode realizar ações no navegador (depuração web com IA), conectar-se aos seus aplicativos de chat e de anotações, interagir com seus bancos de dados, obter contexto do seu sistema de design, obter problemas e contexto de repositório do GitHub e integrar-se com suas plataformas de nuvem. O poder do modo agente está na diversidade de ferramentas disponíveis e na flexibilidade de adicionar e remover ferramentas conforme necessário. Estamos lançando a extensibilidade em preview e disponível para todos os usuários.

O modo agente pode usar as seguintes ferramentas:

Ferramentas integradas contribuídas pelo VS Code (azul no diagrama), que permitem ao agente pesquisar no workspace, aplicar mudanças de código, executar comandos no terminal, capturar erros de compilação ou linting do editor, buscar conteúdo de sites (#fetch para acionar manualmente), e mais.
Ferramentas contribuídas por servidores MCP (verde no diagrama).
Ferramentas contribuídas por extensões do VS Code (verde no diagrama).

Quando a equipe do VS Code inventou o Protocolo de Servidor de Linguagem (LSP) em 2016, nosso objetivo era padronizar como os servidores de linguagem se comunicam com as ferramentas de desenvolvimento. Estamos orgulhosos de que o LSP se tornou um padrão amplamente adotado e cumpriu nossa visão. Recentemente, as ideias por trás do LSP inspiraram um novo protocolo: o Protocolo de Contexto de Modelo (MCP), que padroniza como as aplicações fornecem contexto para LLMs. Com o modo agente no VS Code usando ferramentas contribuídas por servidores MCP, agora completamos o ciclo de volta ao VS Code.

É sobre controle do desenvolvedor

Nem toda tarefa precisa de todas as ferramentas que você pode ter adicionado ao modo agente, e como em qualquer fluxo de trabalho de IA, ser específico leva a melhores resultados. Recomendamos usar a interface de ferramentas para gerenciar e habilitar as ferramentas necessárias para cada cenário ou referenciar explicitamente as ferramentas em seu prompt digitando #.

Para lhe dar total controle, cada invocação de ferramenta é exibida de forma transparente na interface e requer sua aprovação (exceto para ferramentas integradas de leitura). Você pode permitir uma ferramenta específica para a sessão atual, workspace ou todas as invocações futuras. Se você quiser minimizar interrupções permitindo sempre que o agente use todas as ferramentas, enquanto ainda mantém a segurança, considere usar a extensão Dev Containers. Isso isola todas as mudanças feitas pelo agente dentro do ambiente do contêiner até certo ponto (por exemplo, o agente ainda pode enviar mudanças para o remoto se você permitir).

Comece agora

Para personalizar o agente para seus fluxos de trabalho, selecione o ícone de "Ferramentas" na entrada do chat e siga o fluxo Adicionar Mais Ferramentas.... Alternativamente, leia nossa documentação do servidor MCP, que explica o formato de configuração, como adicionar um servidor MCP ou como importar servidores MCP de um aplicativo cliente MCP existente, como o Claude Desktop. O VS Code suporta entrada/saída padrão local (stdio) e eventos enviados pelo servidor (sse) para transporte de servidor MCP.

O repositório oficial de servidores do MCP é um ótimo ponto de partida para servidores oficiais e contribuídos pela comunidade que mostram a versatilidade do MCP. Para instalar extensões que contribuem com ferramentas, abra a visualização de Extensões e pesquise usando a tag @tag:language-model-tools.

Como desenvolvedor, você pode estender o agente criando um servidor MCP, ou se você é um autor de extensão, pode contribuir com ferramentas para sua extensão do VS Code. Consulte estes documentos para orientações e melhores práticas sobre como escrever ferramentas.

O que vem a seguir

O modo Agente está melhorando a cada dia, e para estar entre os primeiros a se beneficiar, considere instalar o VS Code Insiders. Usar o VS Code Insiders e fornecer feedback em nosso repositório é a melhor maneira de nos ajudar a melhorar o produto. Em seguida, planejamos trabalhar em:

Suporte para modos personalizados com conjuntos de ferramentas e instruções personalizadas
Uma experiência de aplicação de código mais rápida
Expandir o suporte MCP de ferramentas para prompts, recursos e as atualizações mais recentes das especificações
Transmissão de edições limitada a blocos de código alterados para melhorar a velocidade
Pontos de verificação para voltar facilmente a uma etapa específica na sua sessão de modo agente
Melhorias gerais de desempenho e qualidade de serviço

Certifique-se de estar na versão mais recente do VS Code Stable, configure chat.agent.enabled nas suas configurações e selecione Agente no menu suspenso do modo. Experimente hoje e nos diga o que você acha! Você pode encontrar a documentação aqui.

Aprenda IA Generativa com JavaScript: Curso Gratuito e Interativo! 💡🤖

Glaucia_Lemos — Wed, 02 Apr 2025 00:27:37 GMT

No vídeo mais recente do meu Canal do YouTube, o time de Advocacia de JavaScript + A.I da Microsoft apresenta uma iniciativa inovadora para desenvolvedores que querem dar os primeiros passos com Inteligência Artificial: o curso gratuito Generative AI with JavaScript. Combinando aprendizado técnico com uma experiência gamificada, o curso é uma excelente porta de entrada para quem deseja explorar IA Generativa usando JavaScript/TypeScript.

Vamos falar um pouco mais sobre o curso e como ele pode ajudar você a se tornar um desenvolvedor mais habilidoso e atualizado com as últimas tendências em tecnologia.

Sobre o Curso: Generative AI with JavaScript

Gravei um vídeo onde explico os principais conceitos abordados no curso, incluindo técnicas de IA Generativa, exemplos práticos e dicas para maximizar seu aprendizado. Se você não assistiu, deixo o link abaixo em português, com legendas em inglês.

O vídeo começa com uma introdução ao repositório do curso, hospedado na organização oficial da Microsoft no GitHub.

O curso propõe uma abordagem única, utilizando o conceito de viagens no tempo, onde você interage com personagens históricos como Leonardo da Vinci, Ada Lovelace, Montezuma e muitos outros, enquanto aprende os fundamentos de IA.

Essa narrativa envolvente é suportada por conteúdo técnico sólido. Cada lição contém material didático em formato de leitura, desafios práticos com exercícios e quizzes, além de um aplicativo complementar onde você pode conversar com os personagens históricos usando modelos de linguagem (LLMs). A combinação de storytelling e tecnologia torna o processo de aprendizado imersivo e acessível.

A experiencia do Curso

Durante o vídeo, eu fiz uma tour completa pelo repositório, destacando que o curso ainda está em inglês (agora já está disponível em português!!).

O curso está estruturado em cinco lições iniciais, com a promessa de atualizações frequentes, acompanhando a evolução acelerada do campo de IA Generativa. Hoje falamos de RAG (Retrieval Augmented Generation), amanhã já estamos explorando Model Context Protocol e agentes inteligentes. Por isso, o repositório deve ser visto como um projeto vivo e em constante expansão.

Para começar a estudar o curso, você pode tanto clonar o repositório localmente quanto usar o GitHub Codespaces, uma alternativa recomendada no vídeo. Com 60 horas gratuitas por mês, o Codespaces permite iniciar o ambiente de desenvolvimento completo direto do navegador, sem necessidade de instalações locais. Essa praticidade democratiza o acesso ao conteúdo, especialmente para quem tem recursos limitados.

Uma vez dentro do Codespaces, você encontrará um ambiente pré-configurado com todas as dependências necessárias para executar os exemplos e desafios do curso. O repositório contém um arquivo README.md com instruções detalhadas sobre como configurar o ambiente, além de links para o aplicativo complementar e outros recursos úteis.

Na primeira lição, por exemplo, os alunos aprendem sobre os fundamentos da IA Generativa e os LLMs, explorando suas aplicações e limitações no contexto de desenvolvimento com JavaScript. Além do conteúdo textual, há um vídeo introdutório e slides complementares, oferecendo múltiplas formas de aprendizado.

Um Curso com Personagens Históricos!

Um dos pontos altos do curso é o Characters App, uma aplicação interativa que simula conversas com figuras históricas utilizando LLMs. O vídeo mostra como rodar essa aplicação diretamente no Codespaces, bastando navegar até a pasta correta, executar os comandos npm install e npm run start, e abrir a porta 3000 no navegador integrado.

Ao iniciar o app, os usuários podem escolher personagens como Dinocrates de Alexandria, Leonardo da Vinci, Ludovico Sforza, Montezuma e Ada Lovelace. Cada um responde com sua personalidade e contexto histórico, permitindo ao aluno experimentar diferentes estilos de interação com IA.

A experiência é enriquecida com suporte a voz, dando ainda mais vida aos personagens e estimulando uma forma lúdica de compreender os conceitos de IA. É uma abordagem que combina aprendizado técnico com imersão cultural e histórica.

Aprendizado Guiado com Exercícios

Outro aspecto importante do curso é que ele não se limita a conceitos teóricos. Cada lição vem acompanhada de exercícios práticos, que desafiam o aluno a aplicar o que foi aprendido. O vídeo mostra onde localizar esses desafios e como encontrar as soluções propostas, o que ajuda tanto quem está começando quanto quem quer revisar seus conhecimentos.

A ideia é que você realmente se envolva com o conteúdo. Ao invés de apenas consumir o que está pronto, você é incentivado a tentar resolver os problemas por conta própria antes de consultar a solução. Essa abordagem ativa favorece a retenção do conhecimento.

Além disso, há dicas úteis para configurar o ambiente, usar o GitHub Copilot e aproveitar as requisições gratuitas de modelos como Claude, Gemini e GPT-4o. O vídeo reforça que, hoje em dia, há múltiplas opções para quem deseja aprender e experimentar com IA sem precisar gastar dinheiro, entre elas o uso do GitHub Models!

Conclusão

Fica o convite! Explore o curso com calma, interaja com os personagens, faça os exercícios e acompanhe todas as atualizações direto no repositório do curso. Assim, você estará sempre à frente no aprendizado de IA Generativa com JavaScript/TypeScript

Se você ainda não explorou o curso, essa é a hora. Dê um fork no repositório, experimente o curso direto no Codespaces, converse com Da Vinci ou Ada Lovelace, e comece a construir seu próprio conhecimento em IA Generativa com JavaScript.

Você está há um passo de se tornar expert em IA Generativa com JAvaScript - comece agora mesmo com um simples git clone!

Use IA de Graça com GitHub Models e TypeScript! 💸💸💸

Glaucia_Lemos — Tue, 01 Apr 2025 23:56:06 GMT

A Inteligência Artificial está se tornando cada vez mais acessível para desenvolvedores. Porém, um dos maiores desafios ainda é o custo das APIs de modelos avançados, como GPT-4o e tantos outros. Felizmente, o GitHub Models veio para mudar esse cenário! Agora, você pode experimentar IA de graça, sem precisar de uma chave de API paga ou baixar modelos pesados em suas máquinas locais.

Neste artigo, vamos explicar em detalhes o que é o GitHub Models e como utilizar gratuitamente com TypeScript em um projeto prático. Escolhemos como exemplo o projeto Microblog AI Remix, um projeto open source de microblog com funcionalidades de IA.

Iremos abordar a estrutura desse projeto e demonstrar passo a passo como integrar com o GitHub Models, substituindo a necessidade de fazer uso de LLMs pagos, incluindo comparações de código antes e depois das modificações. Também veremos como configurar e executar o projeto localmente, e discutiremos as vantagens e limitações do GitHub Models para prototipagem de projetos em IA.

Pode ter certeza que, ao final deste artigo, você terá uma compreensão sólida do GitHub Models e como utilizá-lo em seus próprios projetos e começar a explorar o mundo da IA de forma acessível e gratuita.

Vamos lá!

O que é o GitHub Models?

O GitHub Models é uma iniciativa do GitHub que disponibiliza uma coleção de modelos de IA prontos para uso, integrados à plataforma. Pense no GitHub Models como um Marketplace de Modelos de IA: onde os desenvolvedores podem descobrir modelos de linguagem grande (LLMs) de diferentes provedores, testar suas capacidades em um playground interativo e incorporar em suas aplicações de forma simplificada.

Há modelos de diversas origens e portes - por exemplo, o OpenAI GPT-4o, modelos Open Source como o Meta Llama 3.1, o Phi-3 da Microsoft, o Mistral Large 2, entre outros. Todos podem ser acessados gratuitamente para fins de experimentação.

Uma das grandes vantagens do GitHub Models é permitir o uso gratuito desses modelos durante a fase de prototipagem. Ou seja, você pode testar e construir um proof of concept (POC) sem custos, utilizando a infraestrutura fornecida pelo GitHub. Na prática, existem duas maneiras de interagir com os modelos:

Playground (interface web): nesse playground, você pode testar os modelos diretamente no navegador do GitHub. Nele, você pode fazer perguntas e obter respostas em tempo real com diferentes modelos, ajustar parâmetros (temperatura, número máximo de tokens e etc.) e até comparar lado a lado a saída de dois modelos diferentes.

Via API/SDK: agora, caso você necessite integrar algum modelo em um projeto, o GitHub Models também disponibiliza uma API REST e SDKs para diversas linguagens, como Python, JavaScript/TypeScript, Java, C#, e REST. Cada modelo possui um endpoint de inferência público. Você pode fazer chamadas HTTP para esses endpoints ou usar SDKs (como o SDK do Azure OpenAI ou o próprio SDK do GitHub Models) em diversas linguagens.

A autenticação é feita de forma simples com um token de acesso pessoal do GitHub (PAT), sem necessidade de chaves de API separadas. Basta gerar um PAT na sua conta do GitHub (sem escopos especiais, usando a opção Beta disponível), e usá-lo nas requisições. Em outras palavras, seu token do GitHub funciona como a credencial para chamar o modelo, dentro dos limites gratuitos de uso.

Vantagens e Limitações

Mas, tudo que é gratuito tem suas limitações, certo? Então, vamos explicar as limitações do GitHub Models.

Atualmente, há restrições de chamadas por minuto e por dia, quantidade de tokens por requisição e número de requisições simultâneas. Por exemplo, modelos de categoria low (menores) permitem algo em torno de 15 requisições por minuto e 150 por dia, enquanto modelos high (como o GPT-4o) possuem limites um pouco mais baixos por serem mais pesados

Mas, e se curtiu o modelo e desejar colocar em produção? Bom, nesse caso, o GitHub Models sugere a migração para um endpoint pago do Azure – e o interessante é que basta trocar o token do GitHub por uma chave do Azure que o resto do código continuará funcionando, sem necessidade de alterações adicionais!

Resumindo: o GitHub Models é uma maneira prática de encontrar e experimentar modelos de IA de ponta gratuitamente. Com ele, desenvolvedores podem incorporar funcionalidades de IA em projetos TypeScript (ou de outras linguagens) usando apenas uma conta GitHub. A seguir, conheceremos o exemplo do Microblog AI Remix e, depois, veremos na prática como usar o GitHub Models nesse projeto.

Microblog AI Remix com GitHub Models

O Microblog AI Remix (ou simplesmente Microblog AI) é um projeto de exemplo que combina um aplicativo web de microblog com recursos de Inteligência Artificial. Ele foi criado para demonstrar como construir aplicações web modernas e escaláveis utilizando a stack da Microsoft Azure juntamente com técnicas de Server-Side Rendering (SSR) e IA generativa. Em alto nível, o Microblog AI permite que usuários criem e visualizem pequenos posts de blog (microblogs), contando com a ajuda de um modelo de IA avançado para gerar conteúdo a partir de sugestões do usuário.

Aproveito para pedir a testarem o projeto, dando um fork e contribuindo com melhorias. O projeto é open source e pode ser testado no GitHub Codespaces. Deixa a sua estrela ⭐️ e contribua com melhorias!

Originalmente o projeto utiliza o Azure OpenAI como provedor de IA, mas vamos substituí-lo pelo GitHub Models para proporcionar uma alternativa gratuita e acessível.

Passo a Passo para Configurar o Microblog AI

Eu gravei um vídeo mostrando o passo a passo em como migrar o projeto para o GitHub Models. O vídeo está disponível no meu canal do YouTube (em português) e você pode assisti-lo aqui:

Antes de tudo precisamos clonar o projeto e configurar as dependências. Siga os passos abaixo:

Clone o repositório oficial do Microblog AI Remix:

git clone https://github.com/Azure-Samples/microblog-ai-remix.git cd microblog-ai-remix

2. Instale as dependências do projeto:

npm install cd server npm install

3. Crie um arquivo .env na raiz do projeto e adicione as seguintes variáveis de ambiente:

GITHUB_MODELS_ENDPOINT=https://models.inference.ai.azure.com GITHUB_MODELS_TOKEN=SEU_TOKEN

Esse token você pode gerar na sua conta do GitHub em Settings > Developer Settings > Personal Access Tokens > Generate new token (beta).

4. No diretório /server, crie o arquivo local.settings.json com o seguinte conteúdo:

{ "IsEncrypted": false, "Values": { "AzureWebJobsStorage": "UseDevelopmentStorage=true", "FUNCTIONS_WORKER_RUNTIME": "node", "GITHUB_MODELS_ENDPOINT": "https://models.inference.ai.azure.com", "GITHUB_MODELS_TOKEN": "SEU_TOKEN" }, "Host": { "LocalHttpPort": 7071, "CORS": "*", "CORSCredential": true } }

5. Agora, vá até o arquivo: app/services/openaiService.ts e faça as seguintes alterações:

Importação do Cliente OpenAI: substitua a importação do AzureOpenAI para OpenAI:

import { OpenAI } from "openai";

Renomeação da Classe e Cliente: Substituição da importação do AzureOpenAIService foi renomeada para GitHubModelsService. E, a instância do cliente AzureOpenAI foi renomeada para OpenAI. Adição de um modelName padrão (gpt-4o) para ser usado nas requisições de criação de completions. Porém aqui poderia ser quaisquer outro modelName de sua escolha, como o Llama 3.1 ou o Mistral 7B.

class GitHubModelsService { private client: OpenAI; private readonly toneGuidelines: ToneGuidelines; private readonly modelName: string = "gpt-4o"; (...)

Configuração do Cliente: As variáveis de ambiente específicas do Azure (AZURE_OPENAI_API_KEY, AZURE_OPENAI_ENDPOINT, etc.) foram substituídas por variáveis de ambiente do GitHub (GITHUB_TOKEN e GITHUB_MODELS_ENDPOINT).

this.client = new OpenAI({ baseURL: process.env.GITHUB_MODELS_ENDPOINT || "https://models.inference.ai.azure.com", apiKey: process.env.GITHUB_TOKEN, });

Exportação da Instância da Classe: A instância exportada da classe foi renomeada de azureOpenAIService para GitHubModelsService.

export const azureOpenAIService = new GitHubModelsService();

E pronto! Agora você já pode executar o projeto localmente e testar as funcionalidades de IA com o GitHub Models. Se desejar saber mais detalhes do que foi alterado deixei disponível uma branch chamada feat/github-models-usage com todas as alterações feitas. Você pode comparar com a branch main para ver o que foi modificado.

6. Por fim, para executar o projeto, basta rodar o seguinte comando na raiz do projeto:

npm run build:all npm run dev

Agora, você pode acessar a aplicação na URL: http://localhost:5173/ e começar a criar seus microblogs com a ajuda do GitHub Models!

Conclusão

O GitHub Models é uma excelente alternativa para quem quer experimentar IA sem custos. Ele permite testar modelos avançados como GPT-4o sem precisar pagar por APIs ou configurar infraestrutura complexa. No caso do Microblog AI Remix, conseguimos substituir a API paga do Azure OpenAI pelo GitHub Models com mínimas alterações no código, tornando a aplicação acessível para qualquer desenvolvedor.

Claro que, novamente, caso você queira colocar em produção, o GitHub Models sugere a migração para um endpoint pago do Azure. Mas, para fins de prototipagem e aprendizado, ele é uma ferramenta poderosa e gratuita.

Se você gostou deste artigo, não esqueça de testar o Microblog AI Remix e dar uma ⭐ no repositório! Queremos saber sua opinião sobre essa abordagem e como você pretende utilizar IA nos seus projetos.

Agora é sua vez: clone o repositório, teste as mudanças e explore o GitHub Models gratuitamente. Bora codar com IA sem gastar nada! 💸💸💸

Novidades no Visual Studio Code 1.98

cynthiazanoni — Tue, 18 Mar 2025 15:49:21 GMT

A versão 1.98 do Visual Studio Code está no ar e traz uma série de novidades que vão aprimorar ainda mais a sua experiência de desenvolvimento. Entre os destaques principais, estão recursos que integram de forma ainda mais profunda a inteligência artificial do GitHub Copilot, como o Modo Agente (prévia), o Copilot Edits para notebooks, e o inédito Copilot Vision, que permite interagir com imagens diretamente nas conversas de chat.

Se quiser conferir as atualizações completas, acesse a página de Atualizações no site oficial.

Insiders: Quer testar as novidades o quanto antes? Baixe a versão Insiders e explore os recursos mais recentes assim que estiverem disponíveis!

Copilot Agent Mode (Preview)

O Copilot Agent Mode (preview), transforma a interação com o código: ele busca automaticamente contexto no projeto, sugere comandos no terminal e edita arquivos de forma autônoma. Com isso, tarefas inteiras podem ser automatizadas!

Destaques:

Comandos de terminal visíveis inline, podendo ser editados antes da execução.
Ações de desfazer/refazer específicas para edições realizadas pelo agente.
Integração com tarefas de compilação automáticas (configurável).

Copilot Edits em Notebooks (Preview)

A partir de agora, é possível editar notebooks diretamente com o Copilot, facilitando fluxos de trabalho para cientistas de dados e profissionais que utilizam documentação técnica.

Criação, modificação e exclusão de células.
Suporte completo para diferentes tipos de células.

Interface Renovada nas Edições do Copilot

A interface de Edições foi redesenhada para melhorar a experiência de revisão de arquivos modificados. Os arquivos aparecem como anexos comuns e a lista de arquivos alterados fica logo acima do chat.

Terminal IntelliSense (Preview)

Uma verdadeira revolução para quem gosta de trabalhar no terminal: IntelliSense agora funciona direto no terminal do VS Code!

Principais benefícios:

Sugestões inteligentes para bash, zsh, fish e PowerShell.
Completions para comandos git, npm, brew, ssh e muito mais.
Integração com branches do Git, CDPATH e aliases personalizados.

Autocomplete para git checkout:

Ative o Terminal IntelliSense:

"terminal.integrated.suggest.enabled": true

Next Edit Suggestions (Preview)

O Copilot agora oferece sugestões de próximas edições, tornando o fluxo de trabalho ainda mais fluido. Com o modo colapsado, você foca apenas no que interessa:

Sugestões aparecem discretamente na margem.
Ative-as apenas quando quiser navegar até elas.

Menu de ativação do modo colapsado:

Configuração

github.copilot.nextEditSuggestions.enabled

Copilot Vision (Preview)

Nós estamos rapidamente implementando suporte de visão de ponta a ponta nesta versão do Copilot Chat. Isso permite que você anexe imagens e interaja com imagens em solicitações de chat.

Por exemplo, se você encontrar um erro durante a depuração, anexe uma captura de tela do VS Code e peça ao Copilot para ajudá-lo a resolver o problema. Você também pode anexar um mockup de UI e deixar o Copilot fornecer algum HTML e CSS para implementar o mockup.

Você pode anexar imagens de várias maneiras:

Arraste e solte imagens do seu sistema operacional ou da visualização Explorer
Cole uma imagem da sua área de transferência
Anexe uma captura de tela da janela do VS Code (selecione o botão de clipe de papel 📎 > Captura de Tela da Janela)

Um aviso é mostrado se o modelo selecionado atualmente não tiver a capacidade de lidar com o tipo de arquivo. O único modelo suportado no momento será GPT 4o, mas o suporte para anexos de imagem com Claude 3.5 Sonnet e Gemini 2.0 Flash será lançado em breve também. Atualmente, os tipos de imagem suportados são JPEG/JPG, PNG, GIF e WEBP.

Disponibilidade geral de instruções personalizadas

Instruções personalizadas permitem que você adapte o GitHub Copilot para fornecer respostas de chat e sugestões de código de acordo com a forma como você e sua equipe trabalham. Descreva seus requisitos específicos em formato Markdown em um arquivo .github/copilot-instructions.md no seu espaço de trabalho.

Neste marco, estamos disponibilizando instruções personalizadas com .github/copilot-instructions.md de forma geral. Certifique-se de que a configuração do VS Code está habilitada para que o Copilot possa utilizar essas instruções ao gerar respostas.

github.copilot.chat.codeGeneration.useInstructionFiles

Saiba mais sobre instruções personalizadas no Copilot.

Melhorias no descarte de alterações não rastreadas

Ao longo dos anos, recebemos vários relatórios sobre perda de dados porque descartar um arquivo não rastreado excluía permanentemente o arquivo, mesmo que o VS Code mostrasse um diálogo modal deixando claro que o arquivo seria excluído permanentemente.

A partir desta atualização, descartar um arquivo não rastreado moverá o arquivo para a Lixeira quando possível, para que o arquivo possa ser facilmente recuperado. Você pode ativar ou desativar essa funcionalidade acessando as configurações do VS Code e buscando por git.discardUntrackedChangesToTrash.

Hook de commit para diagnósticos (Experimental)

Introduzimos um novo hook de commit que solicita que você resolva quaisquer diagnósticos não resolvidos para os arquivos alterados. Este é atualmente um recurso experimental que pode ser habilitado usando a configuração git.diagnosticsCommitHook.Enabled.

Por padrão, o hook de commit solicita quaisquer diagnósticos de nível de erro, mas as fontes e níveis de diagnóstico podem ser personalizados usando a configuração git.diagnosticsCommitHook.Sources. Experimente e nos dê seu feedback.

Acessibilidade no Copilot Edits

Nós tornamos as Edições do Copilot muito mais acessíveis.

Agora há sinais sonoros para arquivos com modificações e para regiões alteradas (inserções, modificações e exclusões).
O visualizador de diff acessível agora está disponível para arquivos modificados. Assim como nos editores de diff, selecione kb(chatEditor.action.showAccessibleDiffView) para ativá-lo.

activeEditorState variável de título da janela

Nós temos uma nova variável setting(window.title) chamada activeEditorState para indicar informações do editor, como estado modificado, o número de problemas e quando um arquivo tem Edições (Edits) do Copilot pendentes para usuários de leitores de tela. Quando no modo otimizado para leitores de tela, isso é anexado por padrão e pode ser desativado com accessibility.windowTitleOptimized:false.

Barra de título customizada no Linux

A tão pedida barra de título customizada no Linux já está habilitada por padrão!

A barra de título customizada agora está habilitada por padrão no Linux. A barra de título customizada dá acesso a controles de layout, ao menu do Copilot e muito mais.

Você sempre pode reverter para as decorações de título nativas, seja a partir do menu de contexto da barra de título customizada ou configurando setting(window.titleBarStyle) para native.

Estamos felizes com o feedback contínuo sobre essa experiência e já estamos trabalhando para melhorá-la ainda mais em futuros releases com base nos feedbacks da comunidade.

Modelos de IA

Adicionamos mais modelos para escolher ao usar o Copilot. Os seguintes modelos estão agora disponíveis no seletor de modelo no Visual Studio Code e no chat do github.com:

GPT 4.5 (Prévia): O modelo mais recente da OpenAI, GPT-4.5, agora está disponível no Chat do GitHub Copilot para usuários do Copilot Enterprise. O GPT-4.5 é um modelo de linguagem grande projetado com capacidades avançadas em intuição, estilo de escrita e conhecimento amplo. Saiba mais sobre a disponibilidade do modelo GPT-4.5 no post do blog do GitHub.
Claude 3.7 Sonnet (Prévia): Claude 3.7 Sonnet agora está disponível para todos os clientes em planos pagos do Copilot. Este novo modelo Sonnet suporta tanto modos de pensamento quanto de não pensamento no Copilot. Nos testes iniciais, vimos melhorias particularmente fortes em cenários de agente. Saiba mais sobre a disponibilidade do modelo Claude 3.7 Sonnet no post do blog do GitHub.

Conclusão

A versão 1.98 do Visual Studio Code marca um avanço significativo na integração de inteligência artificial ao ambiente de desenvolvimento, com recursos que aumentam a produtividade e oferecem mais controle para desenvolvedores individuais e equipes. As melhorias em Copilot Agent Mode, edições em notebooks, IntelliSense no terminal e personalização de sugestões refletem um esforço contínuo da equipe do VS Code em fornecer uma experiência de desenvolvimento moderna, eficiente e acessível.

Se você deseja explorar todas essas funcionalidades, a atualização para a versão mais recente já está disponível. Além disso, os recursos em prévia podem ser testados por meio da versão VS Code Insiders.

Para mais informações e download, acesse:
➡️ Notas de versão do VS Code 1.98
➡️ VS Code Insiders

Caso tenha feedback ou sugestões sobre os novos recursos, participe das discussões na comunidade do GitHub do VS Code.

Use IA de Graça com GitHub Models e TypeScript! 💸💸💸

Glaucia_Lemos — Fri, 07 Mar 2025 02:21:44 GMT

Vamos lá!

O que é o GitHub Models?

Playground (interface web): nesse playground, você pode testar os modelos diretamente no navegador do GitHub. Nele, você pode fazer perguntas e obter respostas em tempo real com diferentes modelos, ajustar parâmetros (temperatura, número máximo de tokens e etc.) e até comparar lado a lado a saída de dois modelos diferentes.

Via API/SDK: agora, caso você necessite integrar algum modelo em um projeto, o GitHub Models também disponibiliza uma API REST e SDKs para diversas linguagens, como Python, JavaScript/TypeScript, Java, C#, e REST. Cada modelo possui um endpoint de inferência público. Você pode fazer chamadas HTTP para esses endpoints ou usar SDKs (como o SDK do Azure OpenAI ou o próprio SDK do GitHub Models) em diversas linguagens.

Vantagens e Limitações

Mas, tudo que é gratuito tem suas limitações, certo? Então, vamos explicar as limitações do GitHub Models.

Microblog AI Remix com GitHub Models

Originalmente o projeto utiliza o Azure OpenAI como provedor de IA, mas vamos substituí-lo pelo GitHub Models para proporcionar uma alternativa gratuita e acessível.

Passo a Passo para Configurar o Microblog AI

Eu gravei um vídeo mostrando o passo a passo em como migrar o projeto para o GitHub Models. O vídeo está disponível no meu canal do YouTube (em português) e você pode assisti-lo aqui:

Antes de tudo precisamos clonar o projeto e configurar as dependências. Siga os passos abaixo:

Clone o repositório oficial do Microblog AI Remix:

git clone https://github.com/Azure-Samples/microblog-ai-remix.git cd microblog-ai-remix

2. Instale as dependências do projeto:

npm install cd server npm install

3. Crie um arquivo .env na raiz do projeto e adicione as seguintes variáveis de ambiente:

GITHUB_MODELS_ENDPOINT=https://models.inference.ai.azure.com GITHUB_MODELS_TOKEN=SEU_TOKEN

Esse token você pode gerar na sua conta do GitHub em Settings > Developer Settings > Personal Access Tokens > Generate new token (beta).

4. No diretório /server, crie o arquivo local.settings.json com o seguinte conteúdo:

5. Agora, vá até o arquivo: app/services/openaiService.ts e faça as seguintes alterações:

Importação do Cliente OpenAI: substitua a importação do AzureOpenAI para OpenAI:

import { OpenAI } from "openai";

Renomeação da Classe e Cliente: Substituição da importação do AzureOpenAIService foi renomeada para GitHubModelsService. E, a instância do cliente AzureOpenAI foi renomeada para OpenAI. Adição de um modelName padrão (gpt-4o) para ser usado nas requisições de criação de completions. Porém aqui poderia ser quaisquer outro modelName de sua escolha, como o Llama 3.1 ou o Mistral 7B.

class GitHubModelsService { private client: OpenAI; private readonly toneGuidelines: ToneGuidelines; private readonly modelName: string = "gpt-4o"; (...)

Configuração do Cliente: As variáveis de ambiente específicas do Azure (AZURE_OPENAI_API_KEY, AZURE_OPENAI_ENDPOINT, etc.) foram substituídas por variáveis de ambiente do GitHub (GITHUB_TOKEN e GITHUB_MODELS_ENDPOINT).

this.client = new OpenAI({ baseURL: process.env.GITHUB_MODELS_ENDPOINT || "https://models.inference.ai.azure.com", apiKey: process.env.GITHUB_TOKEN, });

Exportação da Instância da Classe: A instância exportada da classe foi renomeada de azureOpenAIService para GitHubModelsService.

export const azureOpenAIService = new GitHubModelsService();

6. Por fim, para executar o projeto, basta rodar o seguinte comando na raiz do projeto:

npm run build:all npm run dev

Agora, você pode acessar a aplicação na URL: http://localhost:5173/ e começar a criar seus microblogs com a ajuda do GitHub Models!

Conclusão

Agora é sua vez: clone o repositório, teste as mudanças e explore o GitHub Models gratuitamente. Bora codar com IA sem gastar nada! 💸💸💸

Colaboração e implantação eficientes com GitHub Copilot e GitHub Copilot for Azure

cynthiazanoni — Mon, 24 Feb 2025 22:50:10 GMT

No episódio final do GitHub Copilot Bootcamp Brasil (assista as gravações),Henrique Eduardo Souza, Microsoft MVP e Especialista em arquitetura e IA, apresenta um workshop prático de criação de APIs até a implantação em produção, testes automatizados e integração com pipelines de CI/CD.

Demonstração Prática: Criando uma API com Python

Durante a sessão, Henrique demonstra como criar uma API básica usando Python e FastAPI com o auxílio do Copilot. Ele começa configurando um ambiente local e segue os passos abaixo:

Configuração Inicial:
- Criação de um arquivo app.py com um prompt simples: "Preciso criar uma API em Python que responda 'Oi'".
- O Copilot sugere automaticamente o código necessário para implementar essa funcionalidade.
Gerenciamento de Dependências:
- Utilizando extensões do Copilot, ele gera automaticamente um arquivo requirements.txt contendo as dependências necessárias.
- As dependências são instaladas rapidamente via terminal.
Testes Locais:
- Após configurar a API, Henrique utiliza ferramentas como uvicorn para rodar localmente e validar as funcionalidades.
Automatização com Workspaces:
- O Copilot também permite criar estruturas completas de projetos (como MVC) automaticamente, otimizando ainda mais o processo.

Implantação no Azure com GitHub Actions

Após construir a API localmente, Henrique demonstra como configurá-la para implantação no Azure utilizando pipelines do GitHub Actions:

Configuração do Workflow:
- Criação da pasta .github/workflows no repositório.
- Geração automática de um pipeline YAML pelo Copilot para build e deploy da aplicação.
Configuração do Azure Web App:
- Criação de um recurso no Azure Web App com suporte à versão Python 3.12.
- Download do perfil de publicação (publish profile) e configuração como segredo no repositório do GitHub.
Deploy Automatizado:
- Ao realizar commits no repositório, o pipeline é acionado automaticamente, construindo e implantando a aplicação no Azure.

Henrique também destaca que o pipeline pode ser customizado para incluir etapas adicionais, como validação de segurança ou execução de testes automatizados.

Testes Automatizados com Cobertura Completa

Um dos pontos altos da sessão é a demonstração sobre como escrever testes automatizados utilizando o Copilot:

Geração Automática de Testes:
- Henrique utiliza a funcionalidade "Copilot Generate Tests" para criar testes unitários diretamente na IDE.
- Ele valida os testes localmente usando bibliotecas como pytest.
Cobertura de Testes:
- Adiciona etapas no pipeline para medir a cobertura dos testes utilizando ferramentas como coverage.py.
- Relatórios HTML são gerados automaticamente para análise detalhada.
Execução na Pipeline:
- Os testes são integrados ao pipeline YAML, garantindo que qualquer alteração no código seja validada antes da implantação.

Extensões e Personalizações

Henrique explora extensões adicionais que podem ser integradas ao GitHub Copilot:

Diagramas Automáticos:
- Utilizando ferramentas como Mermaid.js, ele gera diagramas de sequência diretamente da base de código.
Extensões Customizadas:
- Demonstra como criar extensões próprias para validar código conforme padrões corporativos (como integração com Jira).

Essas funcionalidades ampliam ainda mais as possibilidades do Copilot, tornando-o uma ferramenta altamente adaptável às necessidades específicas dos desenvolvedores.

Conclusão

Seja você iniciante ou experiente, explorar as funcionalidades do Copilot pode transformar sua maneira de desenvolver software. Experimente integrá-lo ao seu dia a dia e descubra por que tantos desenvolvedores consideram essa ferramenta indispensável!

Assista as gravações do GitHub Copilot Bootcamp disponíveis em português, comece a utilizar o GitHub Copilot gratuito hoje mesmo!

Crie Testes Unitários e Documentação com GitHub Copilot

cynthiazanoni — Mon, 24 Feb 2025 22:31:35 GMT

Em um ambiente de desenvolvimento ágil, a eficiência é crucial. Durante a sessão "Crie Testes Unitários e Documentação com GitHub Copilot" do GitHub Copilot Bootcamp Brasil (assista as gravações), o especialista Rogério Rodrigues demonstrou, em tempo real, como a IA do GitHub Copilot atua como um "copiloto" para simplificar processos complexos.

Este artigo sintetiza as principais técnicas apresentadas, focando nas funcionalidades que automatizam a geração de documentação, criam testes unitários adaptáveis e produzem diagramas técnicos sem esforço manual.

O que você vai aprender nessa sessão:

Geração de Documentação Contextualizada

Rogério iniciou com um projeto .NET que consumia dados de uma API de previsão do tempo. Selecionando o método WeatherApiClient, ele acionou o comando "Generate Docs" diretamente no Visual Studio Code. Em segundos, o Copilot gerou:

Uma docstring detalhada com parâmetros (city: str) e tipo de retorno (dict)
Explicações claras sobre o fluxo de consumo da API meteorológica
Sugestões de tratamento de erros específicos para APIs REST

"O segredo está em como o Copilot entende o contexto", explicou Rogério. "Ele não apenas descreve o que o código faz, mas antecipa necessidades de documentação técnica que desenvolvedores júnior poderiam esquecer."

Um ponto interessante foi a sugestão do GitHub Copilot para gestão de frota:

class VehicleRental: """Sistema de gestão de aluguéis com validação de pagamentos"""

Ao usar o prompt "gere um README.md com instruções de execução", o Copilot estruturou:

Lista de dependências com versões específicas
Comandos de instalação otimizados para virtualenv
Exemplos de uso da classe PaymentValidator com cenários reais

Testes Unitários

A magia aconteceu quando Rogério alternou entre frameworks de teste sem reescrever código:

Cenário .NET/MSTest:

Selecionou o método PriceValidator
Prompt: "Crie testes com dados mock para valores negativos e acima de R$1000"
Copilot gerou 5 casos de teste com [DataRow] e Assert.ThrowsException

Resultado: Ao pedir "Reescreva usando xUnit", o Copilot:

Substituiu [TestMethod] por [Fact]
Reformulou assertions usando Should().Throw<>() (FluentAssertions)
Adicionou comentários sobre paralelismo de testes

Cenário Python/unittest:
Para a função validate_price, o Copilot propôs:

def test_negative_price_raises_value_error(self): with self.assertRaisesRegex(ValueError, "maior que zero"): validate_price(-150)

"Notem como ele incluiu validação de mensagem de erro – detalhe que 80% dos iniciantes esquecem", destacou Rogério.

Diagramas

Com a extensão Mermaid, Rogério transformou comandos em artefatos técnicos:

Prompt no VS Code:
@mermaid Crie diagrama de classes para RentalService, Vehicle, Payment

Resultado em 15s:

classDiagram Vehicle <|-- Car Vehicle : +String license_plate Vehicle : +register_rental() Payment : +process_credit_card() RentalService : +validate_availability()

"Esses diagramas não são estáticos", explicou. "Atualizam-se automaticamente quando o código muda – crucial para microservices com dezenas de componentes."

Próximos passos

Assista as gravações do GitHub Copilot Bootcamp disponíveis em português, comece a utilizar o GitHub Copilot gratuito e explore os módulos do Microsoft Learn:

Construindo uma Aplicação Web de IA com Python e FastAPI usando o GitHub Copilot

Glaucia_Lemos — Tue, 11 Feb 2025 00:59:07 GMT

Desenvolver aplicações web que envolvem recursos de Inteligência Artificial (IA) pode parecer um projeto complexo, mas o surgimento de ferramentas como o GitHub Copilot provou que esse processo pode ser altamente simplificado.

Durante o GitHub Copilot Bootcamp, organizado pelo Microsoft Reactor São Paulo, a Engenheira de Software Mayumi Shingaki apresentou um exemplo prático de como criar, em poucos minutos, uma API em Python com funcionalidades de IA, mostrando como o GitHub Copilot auxilia na refatoração de código. Embora o título mencionasse o Flask, a palestrante optou por utilizar o FastAPI, ao longo da demonstração, destacando a praticidade e o desempenho desse framework para criação de serviços REST.

Neste artigo, exploraremos em detalhes como foi estruturada a criação dessa aplicação em Python, os motivos para a escolha do FastAPI, a experiencia de usar o GitHub Copilot na prática, e como simples rotas de CRUD ilustram o pontencial de combinar IA, Cloud e boas práticas de programação em um único projeto.

O GitHub Copilot Bootcamp é um evento online e gratuito que tem como intuito demonstrar, de maneira objetiva, o impacto positivo que essa ferramenta pode trazer para o dia a a dia do desenvolvedor.

O GitHub Copilot, que é um assistente de programação baseado em IA, auxilia na produtividade do desenvolvedor, permitindo tarefas repetitivas sejam automatizadas e que a escrita de código siga padrões de qualidade, sempre exigindo revisão e aprovação humana.

O evento conta com desconto de vouchers para as certificações oficiais do GitHub.

Dessa forma, o GitHub Copilot Bootcamp é uma excelente oportunidade para quem deseja aprender mais sobre a ferramenta e claro te ajudar a se capacitar para o mercado de trabalho.

Fique de olho no site oficial do GitHub Copilot Bootcamp para saber mais sobre as próximas edições e se inscrever.

Saiba mais sobre o GitHub Copilot Bootcamp: https://aka.ms/GitHubCopilotBootcampBrasil

Vamos agora aos detalhes da aplicação desenvolvida pela Mayumi durante o evento.

Preparando o Ambiente para o Desenvolvimento

Antes de começar a falar da sessão, se você perder a live, você pode assistir a gravação no canal do Microsoft Reactor São Paulo no YouTube.

Antes de mergulhar na criação da API, a palestrante destacou a importância de ter um ambiente mínimo de desenvolvimento já configurado:

Python (3.7+): linguagem principal escolhida para o exemplo.
PIP: gerenciador de pacotes para instalar bibliotecas como fastapi e uvicorn.
Visual Studio Code: editor de texto com bom suporte à extensão do Copilot, além de diversas outras funcionalidades voltadas ao desenvolvimento em Python.
GitHub Copilot: instalado como plugin no VS Code, liberando acesso ao chat e às sugestões inline.
Postman (ou ferramentas similares): para testar as rotas da API, enviando requisições GET, POST e DELETE.

Com esse conjunto básico de ferramentas, Mayumi mostrou que é possível iniciar um projeto e finalizar um MVP (Minimum Viable Product) em uma única sessão, aproveitando o Copilot para acelerar a fase de implementação.

Por que usar o GitHub Copilot?

O GitHub Copilot é uma ferramenta que utiliza modelos de linguagem de aprendizado profundo para gerar sugestões de código em tempo real, baseadas no contexto do que está sendo escrito. Isso significa que, ao digitar um comentário ou uma descrição de uma função, o Copilot é capaz de inferir o que você deseja fazer e sugerir trechos de código que atendam a essa necessidade.

E Mayumi explicou perfeitamente como essa ferramena pode ser útil para desenvolvedores, especialmente para quem está começando ou para quem deseja acelerar o desenvolvimento de projetos.

Novas funcionalidades do GitHub Copilot

Mayumi também destacou algumas das novas funcionalidades disponíveis no GitHub Copilot. Uma delas é o GitHub Copilot com Chat, que permite que você converse com o assistente de programação para obter sugestões de código. E, nesse mesmo recurso, te permite usar determinados comandos para obter sugestões mais específicas. Como por exemplo:

@workspace: para obter sugestões de código com base no contexto do seu projeto.
@terminal/explain: para explicar algo relacionado ao terminal.

Essas novas funcionalidades tornam o GitHub Copilot ainda mais poderoso e útil para o desenvolvimento de projetos.

Durante a live da Mayumi, ela cita outros comandos. Recomendo vocês assistirem a live para entender melhor como utilizar esses comandos.

Por que FastAPI em vez de Flask?

Apesar do título do vídeo mencionar o Flask, a decisão de demonstrar o FastAPI ocorreu por diversos motivos práticos:

Documentação Automática: o FastAPI gera, por padrão, uma interface visual de documentação em /docs, facilitando o entendimento das rotas disponíveis.
Validação de Dados: via pydantic, o framework oferece suporte nativo para checagem de campos de entrada, reduzindo a chance de erros em produção.
Simplicidade de Código: a forma de definir rotas e modelos é extremamente legível, favorecendo o uso de boas práticas e uma curva de aprendizado menor.
Desempenho: o FastAPI é assíncrono e aproveita recursos do Python 3 que permitem maior escalabilidade em cenários de múltiplas requisições simultâneas.

No exemplo prático, Mayumi desenvolveu um CRUD para gerenciamento de tarefas, demonstrando como o Copilot pode sugerir trechos de rota (POST, GET, DELETE) e modelos Python de forma rápida e baseada no contexto do arquivo.

Arquitetura Limpa e Organização do Código

A palestrante menciona a adoção de conceitos de Clean Architecture e Clean Code, que, embora num nível básico, já ajudam a manter a aplicação organizada. De maneira geral, o código foi separado em camadas:

Models: classes Python que representam as entidades do projeto (por exemplo, uma classe Task com atributos title e description).
Repositories: responsáveis pela persistência de dados; no caso da demo, a persistência foi apenas em memória. Em produção, poderia ser um banco SQL ou NoSQL.
Services/Use Cases: contém a lógica de negócio, como validação de regras, criação de novas instâncias de tarefa e manipulação de dados antes de salvar.
Routes: definem a interface HTTP com o usuário, mapeando rotas (/tasks) a funções que chamam as camadas internas.

Essa estratificação faz com que mudanças na lógica de acesso a dados ou no framework web não impactem a camada de negócio, tornando a aplicação mais modular e sustentável a longo prazo.

Criando a Aplicação Passo a Passo com GitHub Copilot

A maior parte da sessão consistiu em demonstrações ao vivo de como o Copilot pode ajudar durante a programação. As principais interações destacadas foram:

Criação de Estrutura de Projeto: no chat do GitHub Copilot, Mayumi digitou comandos como /new workspace, solicitando que a IA gerasse diretórios e arquivos iniciais de um projeto FastAPI. Em seguida, validou e ajustou manualmente a sugestão até ficar coerente com o que precisava.
Instalação de Dependências: o GitHub Copilot propôs um requirements.txt contendo os pacotes: fastapi, uvicorn, pydantic e outras dependências pertinentes. Com um simples pip install -r requirements.txt, a aplicação já estava preparada para execução local.
Rotas e Controladores: ao iniciar a escrita de uma rota @app.post("/tasks"), o GitHub Copilot sugeriu uma função Python que recebia dados de uma nova tarefa, criava a instância e retornava um JSON de sucesso. Sempre que algo precisava de ajustes — como, por exemplo, mudar a forma de gerar IDs ou incluir campos adicionais — Mayumi editava o código ou pedia ao GitHub Copilot correções pontuais.
Testes Unitários: a palestrante salientou que o GitHub Copilot poderia gerar blocos de teste com facilidade. Bastaria pedir algo como “Crie testes para o arquivo routes.py usando Pytest e verifique criação e listagem de tarefas”. O GitHub Copilot, então, criaria um esqueleto de testes parametrizados, economizando tempo na estrutura básica de verificação.

Durante o processo, alguns erros surgiram, especialmente relacionados a importações incorretas ou referências a módulos inexistentes. Isso exemplificou o fato de que a IA não é infalível. No entanto, Mayumi ressaltou que o GitHub Copilot conta com recursos como /fix, onde o usuário descreve o erro, e a IA analisa o código buscando possíveis soluções.

Esse fluxo de tentativa e correção é comum no desenvolvimento, e o GitHub Copilot pode realmente encurtar o ciclo de depuração.

Testando a API e Explorando a Documentação

Uma vez que o código estava funcional, Mayumi usou o comando:

uvicorn app.main:app --host 0.0.0.0 --port 8000

Assim inicializou a aplicação na porta http://localhost:8000, permitindo que o Postman fizesse requisições HTTP para as rotas /tasks e /tasks/{task_id}.

Para verificar se tudo funcionava corretamente, a palestrante lançou mão do Postman, enviando requisições de criação, listagem e de exclusão de tarefas. As chamadas foram bem-sucedidas e a API retornou dados em JSON, confirmando o funcionamento do CRUD.

Ao acessar http://127.0.0.1:8000/docs, a interface gerada pelo FastAPI exibiu, em forma de Swagger, todas as rotas disponíveis, além de permitir testes rápidos das requisições. Esse recurso de documentação automática é um grande diferencial do FastAPI em relação a frameworks mais básicos.

Observações Importantes e Desafios

Apesar de a experiência ter sido predominantemente positiva, Mayumi ressalta que o GitHub Copilot:

Não deve ser usado de forma cega: é muito importante revisar todas as sugestões, pois a IA não é onisciente e pode propor soluções inconsistentes.
É baseado em contexto: para obter melhores respostas, é necessário que o usuário selecione trechos de código, explique o que deseja no chat ou contextualize o GitHub Copilot sobre o restante do repositório.
Auxilia o aprendizado: mesmo desenvolvedores iniciantes podem descobrir novas práticas de código ao interagir com as sugestões, pedindo explicações sobre por que o GitHub Copilot gerou determinado padrão ou sintaxe.

Além disso, cada empresa pode ter padrões específicos de arquitetura, estilo e segurança. O GitHub Copilot, embora traga melhorias consideráveis de produtividade, necessita ser customizado para respeitar tais diretrizes de cada equipe.

Certificações GitHub

Durante o evento, a Cynthia Zanoni, Developer Advocate de Developer Tools da Microsoft mencionou a grande oportunidade em que os participantes do GitHub Copilot Bootcamp têm de obter descontos em certificações oficiais do GitHub.

Essas certificações são uma excelente forma de validar seus conhecimentos e habilidades em ferramentas como o GitHub Copilot, além de serem um diferencial no mercado de trabalho.

Conclusão

A demonstração conduzida por Mayumi Shingaki evidenciou o quão rápido e prático é desenvolver uma aplicação web de IA em Python quando se tem em mãos ferramentas adequadas. O GitHub Copilot se destaca como um parceiro confiável para criar estrutura de pastas, rotas, testes e corrigir erros, sempre que o desenvolvedor contextualiza bem o que deseja fazer.

Optar por FastAPI em vez de Flask se mostrou uma escolha vantajosa para a prova de conceito apresentada, devido à facilidade de geração de documentação, validação de dados e suporte a recursos assíncronos. A aplicação de “lista de tarefas” demonstrada é simples, mas ilustrativa: mostra como podemos estruturar um CRUD completo em poucos passos, aproveitando o Copilot para acelerar o desenvolvimento.

No fim das contas, o recado principal é que o GitHub Copilot não elimina a necessidade de um bom desenvolvedor, mas potencializa sua atuação ao delegar rotinas padronizadas a uma IA e liberar tempo e esforço para o raciocínio crítico e a criação de valor de negócio. Eventos como o GitHub Copilot Bootcamp, reforçados pela disponibilidade de desafios (Cloud Skills Challenge) e vouchers de desconto, ampliam a curva de aprendizado e a consolidação de boas práticas em todo o ecossistema de desenvolvimento.

E para saber mais sobre o GitHub Copilot Bootcamp, confiram os links abaixo:

E nos vemos no próximo artigo! 🚀

Engenharia de Prompt com o GitHub Copilot

cynthiazanoni — Mon, 24 Feb 2025 21:32:22 GMT

O GitHub Copilot é uma ferramenta de inteligência artificial que ajuda desenvolvedores a escrever código de forma mais rápida e eficiente. Durante o GitHub Copilot Bootcamp Brasil (acesse as gravações), reunimos conteúdos práticos para ensinar como dominar a engenharia de prompts e explorar as funcionalidades do Copilot, aumentando sua produtividade em tarefas do dia a dia, como criar rotas para APIs, automatizar testes e integrar pipelines com GitHub Actions.

O GitHub Copilot é um assistente de programação baseado em IA desenvolvido pelo GitHub em parceria com a OpenAI. Ele utiliza modelos avançados de linguagem, como o GPT-4, para oferecer sugestões contextuais diretamente no editor do desenvolvedor. Seja completando funções, gerando trechos de código ou explicando blocos complexos, o Copilot atua como um parceiro que acelera tarefas repetitivas e permite que os desenvolvedores foquem em problemas estratégicos.

Principais benefícios do GitHub Copilot:

Sugestões Contextuais: Recomendações baseadas no código existente e nos comentários fornecidos.
Compatibilidade com Diversos Editores: Funciona com IDEs populares, como Visual Studio Code, JetBrains IDEs e Neovim.
Geração de Código Completo: Cria funções inteiras ou snippets com base em descrições textuais.
Documentação Automatizada: Auxilia na criação de comentários e documentação alinhados ao código.

Com um plano gratuito disponível, basta ter uma conta no GitHub para ativar o Copilot. Ele pode ser usado no Visual Studio Code (VSCode), via chat integrado, autocomplete enquanto você escreve ou até mesmo pela linha de comando (CLI). Também há uma extensão específica para o Azure (GitHub Copilot for Azure).

De acordo com estudos realizados pelo GitHub, desenvolvedores que utilizam o Copilot relatam até 55% mais produtividade e maior satisfação no trabalho.

Durante a sessão, utilizamos o GitHub Codespaces, uma versão do Visual Studio Code na nuvem. Essa ferramenta permite configurar um ambiente completo de desenvolvimento em poucos minutos, eliminando a necessidade de configurações locais demoradas. O Codespaces oferece 60 horas gratuitas por mês, permitindo pausar e retomar ambientes conforme necessário para uma gestão eficiente dos recursos.

Além disso, ele suporta templates prontos para tecnologias como React, Jupyter Notebooks e .NET. Durante a demonstração, configuramos um projeto FastAPI diretamente no Codespaces e mostramos como ele facilita o desenvolvimento de APIs.

O que é Engenharia de Prompts?

A engenharia de prompts é a prática de estruturar comandos ou instruções para obter os melhores resultados possíveis de modelos de IA generativa. No caso do GitHub Copilot, isso significa criar descrições claras e detalhadas sobre o que você deseja que ele faça.

Por exemplo:

""" Crie uma função para listar cidades por país: - A função deve aceitar 'country' como parâmetro. - Retorne as cidades associadas ao país especificado. - Trate erros caso o país não seja encontrado. """

Com base nesse prompt, o Copilot pode gerar automaticamente:

@app.get("/cities/{country}") def list_cities(country: str): country_cities = { "Brazil": ["São Paulo", "Rio de Janeiro", "Belo Horizonte"], "USA": ["New York", "Los Angeles", "Chicago"], "Japan": ["Tokyo", "Osaka", "Kyoto"] } if country not in country_cities: raise HTTPException(status_code=404, detail="Country not found") return {"cities": country_cities[country]}

Essa abordagem economiza tempo e garante que o código gerado esteja alinhado às especificações fornecidas.

Por que Engenharia de Prompts é importante?

A qualidade das sugestões geradas pelo GitHub Copilot depende diretamente da clareza dos prompts fornecidos. Prompts bem elaborados ajudam a IA a entender melhor o contexto do problema, resultando em saídas mais úteis e precisas.

Alguns benefícios:

Maior Controle sobre as Respostas: Reduz ambiguidades e direciona a IA para produzir exatamente o que você precisa.
Eficiência no Desenvolvimento: Menos ajustes manuais economizam tempo valioso.
Versatilidade: Permite explorar diferentes abordagens para resolver problemas complexos.

Por exemplo, ao criar uma API com FastAPI, um prompt detalhado pode gerar rotas completas com tratamento de erros:

""" Crie uma rota FastAPI para listar cidades por país: - A rota deve ser '/cities/{country}'. - Aceite 'country' como string. - Retorne uma lista das cidades associadas ao país fornecido. - Trate erros caso o país não seja encontrado no dicionário. """

Resultado gerado pelo Copilot:

@app.get("/cities/{country}") def list_cities(country: str): country = country.capitalize() country_cities = { "Brazil": ["São Paulo", "Rio de Janeiro", "Belo Horizonte"], "USA": ["New York", "Los Angeles", "Chicago"], "Japan": ["Tokyo", "Osaka", "Kyoto"] } if country not in country_cities: raise HTTPException(status_code=404, detail="Country not found") return {"cities": country_cities[country]}

Durante esta sessão do GitHub Copilot Bootcamp Brasil, você aprenderá:

Introdução ao GitHub Copilot e Engenharia de Prompts
- Como usar prompts eficazes para gerar código relevante.
Configuração de Ambientes na Nuvem com GitHub Codespaces
- Criar ambientes rápidos e flexíveis na nuvem.
Criação de APIs com FastAPI
- Desenvolver rotas robustas utilizando sugestões do Copilot.
Automatização de Testes com pytest
- Criar testes automatizados para validar funcionalidades da API.
Integração Contínua com GitHub Actions
- Configurar pipelines automatizados para rodar testes e builds.

Conclusão

A combinação entre o GitHub Copilot e a engenharia de prompts representa um salto significativo na forma como desenvolvemos software. Ferramentas como essas permitem não apenas acelerar tarefas repetitivas, mas também melhorar a qualidade do código produzido.

Se você deseja aprender mais sobre essas técnicas, assista as gravações do GitHub Copilot Bootcamp disponíveis em português, comece a utilizar o GitHub Copilot gratuito e descubra como transformar sua maneira de programar utilizando inteligência artificial!