Quickstart: Implementar a infraestrutura do Microsoft Discovery

Neste quickstart, configura o seu ambiente Microsoft Discovery para que possa executar a sua primeira investigação científica alimentada por IA. Podes completar a configuração de duas formas:

• Portal Azure – Crie cada recurso manualmente através de uma experiência guiada e passo a passo. Escolha este caminho se quiser compreender cada componente ou preferir um fluxo de trabalho orientado pela interface.
• Bicep – Implemente a stack completa com um único modelo de infraestrutura como código. Escolha este caminho se quiser uma implementação automatizada e repetível.

Ambos os caminhos fornecem os mesmos recursos essenciais: rede, identidade, armazenamento, um supercomputador com um pool de nós, um espaço de trabalho com implementação de modelo de chat, um contentor de armazenamento e um projeto.

Selecione o separador que corresponder à sua experiência preferida em Implementar infraestrutura do Microsoft Discovery.

Pré-requisitos

Os seguintes pré-requisitos aplicam-se tanto ao portal do Azure como às experiências do Bicep:

• Uma subscrição ativa do Azure que esteja ativada (incluída na lista de permissões) para aceder ao Microsoft Discovery. Se a sua subscrição ainda não estiver ativada, contacte o seu representante da conta Microsoft para solicitar acesso.

• Permissões suficientes na sua subscrição do Azure para registar fornecedores de recursos, atribuir papéis e criar recursos:

  • As funções Proprietário, Administrador do Controlo de Acesso Baseado em Funções ou Administrador de Acesso de Utilizador são necessárias para atribuir funções aos administradores (Administradores de Plataforma, Cientistas e Engenheiros) que gerem e utilizam os recursos do Discovery. Para a lista completa de funções exigidas, consulte Funções exigidas por persona.

  • Um Contribuidor ou um cargo privilegiado superior (por exemplo, Proprietário) é obrigado a registar fornecedores de recursos e criar um grupo de recursos.

    Sugestão

    Para atribuir o conjunto completo de funções da persona Platform Administrator num único comando idempotente, utilize o script PowerShell Set-DiscoveryRoleAssignments.ps1 de código aberto. Veja Atribuir papéis de persona no Microsoft Discovery com um script PowerShell. Este método é o caminho recomendado para integrar múltiplos utilizadores.

• Registe os fornecedores de recursos necessários na sua subscrição. Para mais informações, consulte Registo de fornecedores de recursos. Para se registar Microsoft.Discovery:

  1. Inicie sessão no portal Azure.
  2. Navegue para Subscrições e selecione a sua subscrição.
  3. No menu esquerdo, selecione Fornecedores de Recursos.
  4. Pesquise por Microsoft.Discovery.
  5. Selecione o nome do prestador e selecione Registar.

  Note

  Certifique-se de que os seguintes fornecedores de recursos também estão registados na sua subscrição. Se não, regista-os: Microsoft.Network, Microsoft.Compute, Microsoft.Storage, Microsoft.ManagedIdentity, Microsoft.AlertsManagement, Microsoft.Authorization, Microsoft.CognitiveServices, Microsoft.ContainerInstance, Microsoft.ContainerRegistry, Microsoft.ContainerService, Microsoft.DocumentDB, Microsoft.Features, Microsoft.KeyVault, Microsoft.MachineLearningServices, Microsoft.OperationalInsights, Microsoft.ResourceGraph, Microsoft.Search, Microsoft.Web, Microsoft.Insights, Microsoft.Resources, Microsoft.Sql, Microsoft.App, Microsoft.Bing

• Atribuir a função Discovery NSP Perimeter Joiner. Os espaços de trabalho, as estantes e os supercomputadores do Microsoft Discovery são protegidos ao nível da rede por predefinição através de regras de Perímetro de Segurança de Rede (NSP). Antes de criar o seu primeiro espaço de trabalho, bookshelf ou supercomputador, deve criar a função personalizada Discovery NSP Perimeter Joiner. Depois de o criar, atribua a função personalizada Discovery NSP Perimeter Joiner e a função Reader à aplicação de serviço do plano de controlo do Discovery (o principal de serviço proprietário), para que o plano de controlo possa configurar os perímetros de segurança de rede na sua subscrição. Para instruções passo a passo, consulte Atribuir a função de Unificador de Perímetro NSP.

• Microsoft Foundry, quotas do Azure OpenAI e SKU/quota de VMs disponíveis na sua região escolhida. Consulte Reservas de quota.

• Um grupo de recursos existente, ou permissões para criar um novo. Criar um grupo de recursos requer o papel do Contribuidor na subscrição.

Importante

Microsoft Os recursos Discovery são suportados em três regiões de produção: Este EUA, Suécia Central e Reino Unido Sul. Crie todos os recursos para uma única implementação na mesma região, subscrição e grupo de recursos para simplificar.

Note

Pode associar uma rede virtual a apenas um espaço de trabalho do Microsoft Discovery. Se precisares de múltiplos espaços de trabalho, cria uma rede virtual e sub-redes separadas para cada um.

Importante

Se implantar os recursos de rede num grupo de recursos separado dos outros recursos do Discovery, certifique-se de que atribui a si próprio as permissões apropriadas no grupo de recursos da rede virtual para que o recurso do supercomputador seja implementado com sucesso. As permissões a considerar são Network Contributor e Microsoft Discovery Platform Administrator (Preview). Se usares o modelo Bicep, atualiza-o para criar a rede virtual nesse grupo de recursos separado.

Sugestão

Pode implementar recursos do Discovery com isolamento total da rede. Quando networkIsolation está ativado, todos os recursos estão protegidos dentro da rede privada e só são acessíveis através do endpoint privado e do Perímetro de Segurança de Rede (NSP). Ainda podes aceder ao espaço de trabalho através da rede pública através do Discovery Studio e da API REST. Para bloquear o acesso apenas à sua rede privada, desative o acesso à rede pública para o seu espaço de trabalho e crie endpoints privados para os recursos do espaço de trabalho. Para orientação, consulte Configurar segurança de rede para espaços de trabalho do Microsoft Discovery.

Implementar a infraestrutura do Microsoft Discovery

Selecione o separador do portal Azure para criar cada recurso manualmente, ou o separador Bicep para implementar a stack completa usando um modelo de infraestrutura como código.

portal do Azure

Utilize o portal Azure para criar cada recurso Microsoft Discovery através de uma experiência orientada.

1. Configurar redes, identidade e armazenamento

Antes de avançar com a implementação dos componentes da infraestrutura do Microsoft Discovery, utilize um grupo de recursos existente ou crie um novo.

a. Atribuir funções aos administradores

Sugestão

Em vez de atribuir individualmente, através do portal do Azure, as funções indicadas abaixo, pode atribuir o conjunto completo de funções da persona Platform Administrator num único comando idempotente, utilizando o script do PowerShell de código aberto Set-DiscoveryRoleAssignments.ps1. Veja Atribuir papéis de persona no Microsoft Discovery com um script PowerShell. Este é o caminho recomendado para integrar múltiplos utilizadores.

Atribuir os seguintes papéis incorporados aos utilizadores no âmbito desejado (subscrição ou grupo de recursos):

• Administrador da Microsoft Discovery Platform (Pré-visualização)
• Contribuidor de identidade gerenciada
• Operador de identidade gerenciada
• Contribuidor da conta de armazenamento
• Contribuidor de Dados de Storage Blob
• Contribuidor de Rede
• ACRPush
• Utilizador do Foundry
• Microsoft Discovery Bookshelf Index Data Reader - Pré-visualização

Note

Se estiveres a atribuir todas as funções ao nível da subscrição, podes saltar esta nota. Se estiveres a atribuir funções ao nível do grupo de recursos, ignora, para já, a função Foundry User. Continue com os próximos passos e volte a esta atribuição de função depois de criar o recurso do espaço de trabalho. Esta função deve ser atribuída a cada utilizador Administrador de Plataforma ou Cientista ao nível do grupo de recursos gerido pelo espaço de trabalho.

Passos para atribuir funções:

1. Inicie sessão no portal Azure.
2. Navegue para Subscrições e selecione a sua subscrição.
3. No menu esquerdo, selecione Controlo de acesso (IAM) .
4. Selecione Adicionar e, em seguida, selecione Adicionar atribuição de função.
5. No painel Adicionar atribuição de funções , procure cada função uma de cada vez e selecione Próximo.
6. No separador Membros , certifique-se de que Atribuir acesso a está definido como Utilizador, grupo ou principal de serviço.
7. Selecionar + Selecionar membros, escolher os membros a atribuir esta permissão e depois selecionar Próximo.
8. No separador Condições , selecione Permitir que o utilizador atribua todos os papéis exceto os papéis de administrador privilegiado Proprietário, UAA, RBAC (Recomendado), e depois selecione Próximo.
9. Na aba Tipo de Atribuição, selecione a configuração que melhor se adequa à sua organização e depois selecione Seguinte.
10. No separador Rever + atribuir, verifique a informação e selecione Rever + atribuir.

Repita este processo para todas as funções necessárias.

b. Criar uma rede virtual e sub-redes

1. Inicie sessão no portal Azure.
2. Procure por redes virtuais e selecione-as nos resultados.
3. Selecione Criar para começar a criar uma nova rede virtual.
4. Introduza detalhes como Subscrição, Grupo de Recursos, Nome e Região, e depois selecione Próximo.
5. Configurar endereços IP:
   • Espaço de endereçamento IPv4: Introduza o bloco CIDR (Classless Inter-Domain Routing) escolhido (por exemplo, 10.0.0.0/16).
   • Adicione as seguintes sub-redes:
     • supercomputerNodepoolSubnet: 10.0.1.0/24
     • aksSubnet: 10.0.2.0/24
     • workspaceSubnet: 10.0.3.0/24
     • privateEndpointSubnet: 10.0.4.0/24
     • agentSubnet: 10.0.5.0/24
     • searchSubnet: 10.0.6.0/24
6. Para workspaceSubnet, agentSubnet e searchSubnet, em SubnetDelegation, selecione Microsoft.App/environments.
7. Para workspaceSubnet, agentSubnet, supercomputerNodepoolSubnet e aksSubnet, em Service Endpoints, adicione Microsoft.Storage.
8. Opcionalmente, podes remover a default sub-rede da lista.
9. Reveja e crie a rede virtual.

Note

Os Grupos de Segurança de Rede (NSGs) não são mencionados neste passo, mas é uma prática geral recomendada implementar NSGs para cada sub-rede numa rede virtual, dependendo das políticas da sua organização.

c. Criar uma identidade gerida atribuída pelo próprio utilizador (UAMI)

Pode criar diferentes UAMIs, cada um com as suas próprias permissões necessárias para acesso específico a recursos, ou pode criar um único UAMI com todas as permissões necessárias para a plataforma. Para este exercício, crie um único UAMI seguindo estes passos:

1. Inicie sessão no portal Azure.
2. Procure Identidades Geridas e seleciona-a da lista.
3. Selecione Criar.
4. Preencha os dados necessários, como subscrição, grupo de recursos, região e nome.
5. Selecione Rever + Criar e, depois, selecione Criar.

d. Atribuir funções de Azure Role Based Controlo de Acesso (RBAC) ao UAMI

Atribuir os seguintes papéis incorporados à nova Identidade Gerida Atribuída pelo Utilizador ao nível do Grupo de Recursos:

• Colaborador da Microsoft Discovery Platform (Pré-visualização)
• Contribuidor de Dados de Storage Blob
• ACRPull

1. Navegue para Subscrições e selecione a sua subscrição.
2. Selecione o grupo de recursos que está a usar para este exercício.
3. No menu esquerdo, selecione Controlo de acesso (IAM) .
4. Selecione Adicionar e, em seguida, selecione Adicionar atribuição de função.
5. No painel Adicionar atribuição de funções , procure cada função uma de cada vez e selecione Próximo.
6. No separador Membros, certifique-se de que Atribuir acesso a está definido como Identidade Gerida.
7. Selecione + Selecione membros. No painel Selecionar identidades geridas , selecione a sua subscrição, selecione Tipo de identidade gerida atribuída pelo utilizador , selecione a identidade gerida que criou no passo anterior e depois selecione Selecionar.
8. No separador Rever + atribuir, verifique toda a informação e selecione Rever + atribuir.

e. Criar uma conta Armazenamento de Blobs do Azure

Para armazenar dados de entrada e saída para as suas investigações, crie uma conta de armazenamento blob no Azure para associar ao seu contentor de armazenamento ou use uma existente com os seguintes requisitos:

• Crie um contentor dentro da conta de armazenamento nomeado discoveryoutputs onde os ficheiros de saída são armazenados.
• A conta de armazenamento deve permitir o acesso a partir da Rede Virtual usada para criar o supercomputador e o espaço de trabalho.
• A conta de armazenamento deve permitir o acesso a partir do IP público do cliente ou da rede local para que possa aceder aos dados de saída.
• A conta de armazenamento deve ter as definições corretas de CORS. Deve permitir estas origens: https://studio.discovery.microsoft.com, https://vscode.dev, e https://*.vscode-cdn.net. Defina as operações permitidas para incluir GET, HEAD, DELETE, e PUT e defina Allowed Headers e Exposed Headers para *, e Max Age para 200. Esta definição encontra-se na página de Partilha de Recursos (CORS) no separador Definições .
• Certifique-se de que a conta de armazenamento tem Storage Blob Data Contributor acesso ao UAMI criado na etapa anterior.

Para criar uma conta de armazenamento de Azure blob:

1. Inicie sessão no portal Azure.
2. Procura por contas de armazenamento e seleciona-as nos resultados.
3. Selecione Criar para começar a criar uma nova conta de armazenamento.
4. Insira detalhes como Subscrição, Grupo de Recursos, Nome e Região.
5. Selecione Armazenamento de Blobs do Azure como serviço principal, depois selecione o separador Networking.
6. Em acesso à rede pública, selecione Permitir acesso público a partir de redes virtuais selecionadas e endereços IP.
7. Selecione o Rede Virtual e todas as sub-redes criadas em step 1.
8. Selecione Adicionar o endereço IP do seu cliente se estiver a aceder a dados pela internet, ou certifique-se de que o cliente pode aceder à conta de armazenamento e à rede virtual através de ligação privada, VPN Site-to-Site ou ExpressRoute.
9. Selecione Rever + criar e, em seguida, selecione Criar.

Note

Para visualizar e descarregar ficheiros de saída, a sua aplicação cliente ou navegador precisa de acesso de rede ao armazenamento de blobs. Pode permitir o acesso público à internet abrindo o acesso público a todas as redes. Também pode permitir o endereço IP público do seu cliente nas definições de armazenamento, rede e firewall. Em alternativa, configure o acesso privado via Azure VPN ou ExpressRoute.

Criar um contentor de blobs

1. Depois de criada a conta de armazenamento, navegue até à página de visão geral da conta de armazenamento.
2. No painel de navegação esquerdo, em Armazenamento de Dados, selecione Contentores.
3. Selecione Adicionar contentor.
4. Introduza discoveryoutputs como nome e selecione Criar.

Permitir o acesso ao CORS e UAMI

1. Abra a conta de armazenamento que criámos no passo anterior.
2. No separador Definições, selecione Partilha de Recursos (CORS).
3. Em Blob service, na coluna Allowed origins, introduza https://studio.discovery.microsoft.com, https://vscode.dev e https://*.vscode-cdn.net. Para os três, defina as operações permitidas para incluir GET, HEAD, DELETE, OPTIONS, e PUT. Defina Allowed Headers e Exposed Headers para *, e Max Age para 200.
4. Selecione Guardar.

2. Criar um supercomputador

Precisas de um supercomputador com pools de nós associados para implementar e executar ferramentas científicas, e para indexar os teus dados em bases de conhecimento Bookshelf. O supercomputador também executa cargas de trabalho intensivas em GPU e CPU para simulação e modelação. Fornece os recursos de computação numa rede virtual específica dentro da sua subscrição.

1. Inicie sessão no portal Azure.
2. Procure por Microsoft Discovery Supercomputers.
3. Selecione Criar e introduza detalhes como ID de Subscrição, Nome do Grupo de Recursos, Localização e Nome, depois selecione Próximo.
4. No separador de Redes , selecione a rede virtual e aksSubnet que criou no passo 1, e depois selecione Próximo.
5. No separador SKU do Sistema, selecione Standard_D4s_v6 como SKU do Sistema para esta implementação e selecione Próximo.
6. No separador Identidades , adicione a identidade gerida atribuída pelo utilizador (UAMI) que criou no passo 1 para a identidade do cluster, identidade kubelet e identidade da carga de trabalho. As instâncias de supercomputador usam esta identidade gerida para aceder a dados dos seus recursos Azure. Quando terminar, selecione Avançar.
7. No separador Encryption, como estamos a usar chaves geridas por Microsoft para este exercício, desmarca a opção "Ativar Chaves Geridas pelo Cliente" e selecione Próximo.
8. Adicione etiquetas conforme necessário e passe para o separador seguinte.
9. Consulte os Termos e Condições e selecione Próximo.
10. Quando a validação for bem-sucedida, selecione Criar.

3. Criar grupos de nós

Depois de criado o seu supercomputador, siga estes passos para criar um pool de nós:

1. Abre o Supercomputador que criámos na etapa anterior.
2. No painel esquerdo, selecione grupo de nós em Definições, em seguida, selecione Criar.
3. Introduza o nome e a localização do pool de nós, depois selecione Próximo.

   Note

   Os nomes dos grupos de nós devem ser todos minúsculos, com um máximo de 12 caracteres, devem começar com uma letra e só podem conter letras e números.

4. No separador de Rede , selecione a rede virtual e supercomputerNodepoolSubnet a que criou no passo 1, e selecione Próximo. Nota: Use a mesma rede virtual selecionada para o supercomputador no passo 2.
5. No separador de configuração VM , selecione o SKU de Máquina Virtual (VM) para usar no pool de nós e depois selecione Próximo. O SKU e a quota selecionados devem estar disponíveis na região onde implementas o pool de nós.
6. Na secção Dimensionamento, introduza o número máximo de nós até ao qual o seu conjunto de nós pode dimensionar, por exemplo, 5, e selecione Seguinte.
7. Selecione Rever + Criar e Criar.

4. Criar um espaço de trabalho

Um espaço de trabalho é um ambiente colaborativo onde as equipas gerem iniciativas científicas de grande escala. Os espaços de trabalho reúnem os recursos de infraestrutura, como supercomputadores, agentes, ferramentas e bases de conhecimento (Bookshelves), num único limite seguro. Pode criar projetos em espaços de trabalho, permitindo aos investigadores organizar experiências, analisar dados e usar agentes de IA dentro de um espaço partilhado.

Importante

Certifica-te de que o nome do teu espaço de trabalho é globalmente único e usa apenas letras minúsculas.

1. Inicie sessão no portal Azure.

2. Procure por Microsoft Discovery Workspaces.

3. Selecione + Criar e introduza detalhes como Subscrição, Grupo de Recursos, Nome e Região, depois selecione Próximo.

4. No separador Rede , selecione Acesso Público à Rede como Ativar para este exercício. Depois disso, introduza os detalhes da sub-rede de Endpoint Privado, sub-rede de Agente e sub-rede de Workspace com as sub-redes que criou anteriormente no passo 1, e depois selecione Próximo.

5. No separador Encriptação, deixe a opção Ativar chaves geridas pelo cliente (CMK) desativada. Para este exercício, vamos usar Microsoft Managed Chaves (MMK), basta selecionar Seguinte para passar ao separador seguinte.

6. No separador Supercomputador , selecione Adicionar Supercomputador e selecione a sua subscrição, grupo de recursos e o supercomputador criado no passo 2, depois selecione Próximo.

7. No separador Identidade do Espaço de Trabalho , selecione Adicionar em Identidade Gerida Atribuída pelo Utilizador (UAMI) e selecione a identidade que criou no passo 1 para dar acesso ao espaço de trabalho.

8. No separador de Etiquetas , adicione etiquetas conforme necessário. (Opcional) Para ativar o GitHub Copilot e configurar o acesso ao espaço de trabalho, adicione as seguintes etiquetas. Para mais detalhes, consulte Usar o GitHub Copilot no Microsoft Discovery.

   • discovery.workbench.enableGhcpAiFeatures definido para true — Ativa o GitHub Copilot e as funcionalidades de IA para o espaço de trabalho.
   • discovery.workbench.enableExtensions definido para true — Ativa o VS Code Extension Marketplace na experiência de pré-visualização.
   • NetworkIsolation definido como false — Permite o acesso público à experiência de pré-visualização (workbench) e aos outros recursos do grupo de recursos gerido (MRG). Se mantiveres o isolamento de rede ativado (por defeito), precisas de estar ligado a uma VPN ou ao ExpressRoute na rede virtual onde o espaço de trabalho está implementado para aceder através da rede privada.

   Sugestão

   Pode implementar recursos do Discovery com isolamento total da rede. Quando networkIsolation está ativado, todos os recursos estão protegidos dentro da rede privada e só são acessíveis através do endpoint privado e do Perímetro de Segurança de Rede (NSP). Ainda podes aceder ao espaço de trabalho através da rede pública através do Discovery Studio e da API REST. Para bloquear o acesso apenas à sua rede privada, desative o acesso à rede pública para o seu espaço de trabalho e crie endpoints privados para os recursos do espaço de trabalho. Para orientação, consulte Configurar segurança de rede para espaços de trabalho do Microsoft Discovery.

   Note

   As etiquetas são imutáveis para os tipos de recursos do Microsoft Discovery, incluindo espaços de trabalho, supercomputadores, pools de nós e estantes. Depois de um recurso ser criado, não pode adicionar, alterar ou remover as suas etiquetas. Qualquer modificação de etiqueta, incluindo a adição de uma etiqueta, requer a redistribuição do recurso.

9. Reveja os Condições e Termos e depois selecione Revisar + Criar.

10. Quando a validação for bem-sucedida, selecione Criar.

5. Atribuir a função Foundry User ao grupo de recursos gerido

Quando um espaço de trabalho é criado, um grupo de recursos gerido é automaticamente provisionado juntamente com ele. Para permitir que os utilizadores modifiquem agentes e fluxos de trabalho dentro de um projeto diretamente no portal Foundry para definições avançadas, deve atribuir-lhes o papel de Utilizador Foundry neste grupo de recursos geridos.

1. Inicie sessão no portal Azure.
2. Vai ao espaço de trabalho que criaste no passo 4 e encontra o nome do Grupo de Recursos Geridos na página de visão geral do espaço de trabalho.
3. Navegue até esse grupo de recursos geridos.
4. No menu esquerdo, selecione Controlo de acesso (IAM) .
5. Selecione Adicionar e, em seguida, selecione Adicionar atribuição de função.
6. No painel Adicionar atribuição de função, procure Foundry User e selecione-o; em seguida, selecione Seguinte.
7. No separador Membros , certifique-se de que Atribuir acesso a está definido como Utilizador, grupo ou principal de serviço.
8. Selecionar + Selecionar membros, escolher os utilizadores que precisam de modificar agentes e fluxos de trabalho, depois selecionar Selecionar.
9. Selecione Rever + atribuir, verifique a informação e selecione Rever + atribuir.

Repita este processo para todos os utilizadores que necessitem de acesso a agentes e fluxos de trabalho no espaço de trabalho. Quaisquer alterações feitas diretamente no portal Foundry são refletidas automaticamente na configuração do agente Discovery.

6. Implementação de Modelos de Chat

As implementações de modelos de chat fornecem modelos de linguagem fundamentais como o GPT-5.4 para utilização no Microsoft Discovery Workspace. Os agentes criados dentro dos projetos podem usar estas implementações de modelos de chat.

1. Vá à página de visão geral do Microsoft Discovery Workspace, criado no passo anterior.

2. No separador Definições do painel de navegação esquerdo, selecione Implementações de Modelos de Chat.

3. Selecione a opção + Criar no topo.

4. Insira o Nome como gpt-5-4.

5. Selecione o Formato do Modelo como OpenAI e o Nome do Modelo como gpt-5.4 no menu suspenso.

6. Depois seleciona o botão Rever + criar na parte inferior e seleciona Criar.

   

Importante

Para usar o Discovery Engine e as tarefas nas suas sessões, deve usar esta implantação específica com o nome gpt-5-4 e o nome de modelo gpt-5.4. No entanto, podes ter implementações adicionais de modelos de chat para usar com agentes.

Pode fornecer acesso aos utilizadores através de Role Based Controlo de Acesso (RBAC) ao nível do grupo de recursos. Função de Administrador de Descobertas da Microsoft (Pré-visualização) é necessária para criar projetos dentro de um espaço de trabalho.

7. Iniciar sessão no Microsoft Discovery Studio

O Microsoft Discovery Studio é um ambiente de investigação seguro e alimentado por IA. Permite a cientistas e engenheiros acelerar a inovação através de agentes autónomos, fluxos de trabalho de simulação e ferramentas de dados integradas numa interface unificada.

Depois de a sua infraestrutura estar configurada, pode iniciar sessão no Microsoft Discovery Studio diretamente através do URL, ou encontrar o URL na página de visão geral do Workspace no portal Azure.

Deve iniciar sessão com as suas credenciais Microsoft Entra ID para a sua conta de trabalho ou escola. O Studio suporta login único com o Microsoft Entra ID. Não tem de fornecer credenciais explicitamente se já tiver sessão iniciada noutro serviço com o seu Microsoft Entra ID no mesmo browser.

Note

Se tiver acesso a vários inquilinos Microsoft Entra, selecione o inquilino certo selecionando o ícone do seu perfil no canto superior direito da página.

8. (Opcional) Criar um contentor de armazenamento autónomo

Cada projeto requer um contentor de armazenamento. A forma recomendada de o provisionar é selecionar Criar um contentor de armazenamento para mim durante a criação do projeto no passo 9. Siga este passo apenas se quiser criar e gerir um contentor de armazenamento autónomo — por exemplo, para reutilizar um contentor em vários projetos.

Os contentores de armazenamento armazenam tanto dados de entrada como de saída como ativos de armazenamento. Tanto as entradas como as saídas utilizam um contentor de armazenamento do tipo Armazenamento do Azure Blob, apoiado pela conta de armazenamento criada em step 1.

1. No Microsoft Discovery Studio, no painel de navegação esquerdo em Recursos, selecione Dados.
2. Selecione Criar contêiner.
3. Insira detalhes como nome, subscrição, grupo de recursos e localização.
4. Selecione a conta de armazenamento criada no passo 1.
5. Selecione Criar.
6. Quando crias o projeto, podes selecionar este contentor de armazenamento.

Note

Depois de selecionar Criar, o recurso está inicialmente no estado Aceite . Atualize a página e espere até que o Estado de Provisionamento mude para Succeeded antes de prosseguir. Esta operação normalmente demora alguns minutos.

9. Criar um projeto

Os projetos ajudam-no a organizar e gerir investigações científicas dentro de um espaço de trabalho. Cada projeto define o limite funcional para o acesso aos seus agentes, ferramentas e contentores de armazenamento. Dentro de um projeto, pode realizar experiências, analisar dados, aplicar modelos de IA e acompanhar o progresso da investigação num ambiente colaborativo.

Importante

O nome do seu projeto deve estar todo em minúsculas e não ter mais de 12 caracteres. Além disso, certifique-se de atualizar a página antes de criar um projeto. Pode criar um projeto abrindo o seu espaço de trabalho no estúdio.

1. No Microsoft Discovery Studio, no painel de navegação esquerdo, selecione Espaços de Trabalho. Isto lista todos os espaços de trabalho existentes nas suas subscrições do Azure.

2. Selecione o espaço de trabalho que criou no passo 4. Esta ação abre o seu espaço de trabalho no estúdio.

3. Selecione Criar Projeto.

4. Introduza um nome para o projeto.

5. Mantém a opção Criar um contentor de armazenamento para mim ativada.

6. Em Selecionar Conta de Armazenamento, selecione a conta de armazenamento que criou no passo 1. É criado um novo contentor de armazenamento para o projeto.

   Note

   A opção Criar um contentor de armazenamento para mim cria um novo recurso de contentor de armazenamento no mesmo grupo de recursos do seu espaço de trabalho e projeto. Este método é a forma recomendada de provisionar o contentor de armazenamento que um projeto necessita. Para criar e gerir contentores de armazenamento autónomos para outros cenários, use o passo 8.

   

   

7. Selecione Criar.

Note

Depois de selecionar Criar, o projeto fica inicialmente no estado Aceite . Atualize a página e espere até que o Estado de Provisionamento mude para Succeeded antes de prosseguir.

Bicep

Utilize o Bicep para implementar a infraestrutura necessária para o Microsoft Discovery. A implementação cria os recursos fundamentais do Azure necessários antes de poder usar um espaço de trabalho Discovery, supercomputador e projetos.

Bicep é uma linguagem específica de domínio (DSL) que utiliza sintaxe declarativa para implementar recursos Azure. Fornece sintaxe concisa, segurança de tipos fiável e suporte para reutilização de código. O Bicep oferece a melhor experiência de criação para suas soluções de infraestrutura como código no Azure.

Revise o arquivo Bicep

Esta introdução rápida utiliza um ficheiro Bicep dos Azure Quickstart Templates.

Neste guia de início rápido, implanta toda a stack Microsoft Discovery em Suécia Central. A implementação cria uma rede virtual com um espaço de endereçamento 10.0.0.0/16 e cinco sub-redes para pools de nós de supercomputador, AKS, espaço de trabalho, endpoints privados e agentes. A implementação prevê uma conta de armazenamento Standard_LRS com as regras CORS ativadas para Discovery Studio e VS Code. Cria uma identidade gerida atribuída ao utilizador com atribuições das funções Storage Blob Data Contributor, Discovery Platform Contributor e AcrPull. Os recursos centrais do Discovery incluem um supercomputador com um conjunto de nós Standard_D4s_v6 (com escalabilidade de 0 a 3 nós), um espaço de trabalho com uma implementação de modelo de chat, um contentor de armazenamento e um projeto.

Note

Ativar o Workbench unificado (pré-visualização). O Workbench unificado, que inclui o GitHub Copilot e funcionalidades de IA, está em pré-visualização. Para o ativar, implemente o seu espaço de trabalho com as tags discovery.workbench.enableGhcpAiFeatures: true e discovery.workbench.enableExtensions: true. A forma como acedes à área de trabalho Workbench depende da definição networkIsolation do espaço de trabalho:

• Quando networkIsolation está definido como false, o Workbench funciona imediatamente.
• Quando networkIsolation está definido para true, deve estabelecer uma ligação VPN (ou ExpressRoute) à rede virtual onde o espaço de trabalho está implantado.

Para mais informações, consulte Usar o GitHub Copilot no Microsoft Discovery.

Note

As etiquetas são imutáveis para os tipos de recursos do Microsoft Discovery, incluindo espaços de trabalho, supercomputadores, pools de nós e estantes. Depois de um recurso ser criado, não pode adicionar, alterar ou remover as suas etiquetas. Defina todas as etiquetas necessárias no modelo antes de implementar; Qualquer modificação de etiqueta, incluindo a adição de uma etiqueta, requer a redistribuição do recurso.

@description('Azure region for all resources. Must be a Discovery-supported region.')
@allowed([
  'eastus'
  'swedencentral'
  'uksouth'
])
param location string = 'uksouth'

@description('Azure region for all dataplane resources. Defaults to location when not specified.')
param overridemrgregion string = location

@description('Name of the Microsoft Discovery Supercomputer. Must be 3-24 characters, alphanumeric and hyphens only.')
@minLength(3)
@maxLength(24)
param supercomputerName string = 'sc-${uniqueString(resourceGroup().id)}'

@description('Name of the Node Pool created under the Supercomputer. Must be 1-12 lowercase alphanumeric characters, starting with a letter.')
@minLength(1)
@maxLength(12)
param nodePoolName string = 'nodepool1'

@description('Name of the Microsoft Discovery Workspace. Must be 3-24 characters, alphanumeric and hyphens only.')
@minLength(3)
@maxLength(24)
param workspaceName string = 'ws-${uniqueString(resourceGroup().id)}'

@description('Name of the Chat Model Deployment created under the Workspace.')
@minLength(3)
@maxLength(24)
param chatModelDeploymentName string = 'gpt-5-4'

@description('Name of the Microsoft Discovery Storage Container resource. Must be 3-24 characters, alphanumeric and hyphens only.')
@minLength(3)
@maxLength(24)
param storageContainerName string = 'stc-${uniqueString(resourceGroup().id)}'

@description('Name of the Project created under the Workspace. Must be 3-24 characters, alphanumeric and hyphens only.')
@minLength(3)
@maxLength(24)
param projectName string = 'prj-${uniqueString(resourceGroup().id)}'

@description('Name of the Virtual Network. Must be 2-64 characters: letters, numbers, underscores, periods, or hyphens; must start with a letter or number and end with a letter, number, or underscore.')
@minLength(2)
@maxLength(64)
param vnetName string = 'discovery-vnet'

@description('Name of the User-Assigned Managed Identity.')
param managedIdentityName string = 'uami-${uniqueString(resourceGroup().id)}'

@description('Globally unique name of the Azure Storage Account (3-24 lowercase alphanumeric characters).')
@minLength(3)
@maxLength(24)
param storageAccountName string = 'stg${uniqueString(resourceGroup().id)}'

@description('Name of the blob container inside the Storage Account used for Discovery outputs.')
param blobContainerName string = 'discoveryoutputs'

@description('Replication SKU for the Storage Account. Zone/geo-redundant options are recommended over locally-redundant storage for resiliency.')
@allowed([
  'Standard_ZRS'
  'Standard_GRS'
  'Standard_GZRS'
  'Standard_RAGRS'
  'Standard_RAGZRS'
])
param storageAccountSku string = 'Standard_GRS'

@description('Address space for the Virtual Network.')
param vnetAddressPrefix string = '10.0.0.0/16'

@description('Address prefix for the Supercomputer Node Pool subnet.')
param supercomputerNodepoolSubnetPrefix string = '10.0.1.0/24'

@description('Address prefix for the AKS system subnet used by the Supercomputer.')
param aksSubnetPrefix string = '10.0.2.0/24'

@description('Address prefix for the Workspace subnet (delegated to Microsoft.App/environments).')
param workspaceSubnetPrefix string = '10.0.3.0/24'

@description('Address prefix for the Private Endpoint subnet.')
param privateEndpointSubnetPrefix string = '10.0.4.0/24'

@description('Address prefix for the Agent subnet.')
param agentSubnetPrefix string = '10.0.5.0/24'

@description('Address prefix for Search Subnet.')
param searchSubnetPrefix string = '10.0.6.0/24'

@description('VM SKU for the Node Pool.')
param nodePoolVmSize string = 'Standard_D4s_v6'

@description('Maximum number of nodes in the Node Pool.')
@minValue(1)
param nodePoolMaxNodeCount int = 3

@description('Minimum number of nodes in the Node Pool (0 allows scale-to-zero).')
@minValue(0)
param nodePoolMinNodeCount int = 0

@description('Scale set priority for the Node Pool.')
@allowed([
  'Regular'
  'Spot'
])
param nodePoolScaleSetPriority string = 'Regular'

@description('Chat model format.')
param chatModelFormat string = 'OpenAI'

@description('Chat model name to deploy.')
param chatModelName string = 'gpt-5.4'

@description('Enable GitHub Copilot and AI features in the Discovery workspace via the discovery.workbench.enableGhcpAiFeatures tag.')
param enableGhcpAiFeatures bool = true

@description('Enable the VS Code Extension Marketplace in the Discovery workspace via the discovery.workbench.enableExtensions tag.')
param enableExtensions bool = true

@description('Workspace network isolation mode via the NetworkIsolation tag. Set to false to enable public preview access as documented in the Infrastructure portal quickstart.')
param networkIsolation bool = true

// Built-in role definition IDs
var storageBlobDataContributorRoleId = 'ba92f5b4-2d11-453d-a403-e96b0029c9fe'
var discoveryPlatformContributorRoleId = '01288891-85ee-45a7-b367-9db3b752fc65'
var acrPullRoleId = '7f951dda-4ed3-4680-a7ca-43fe172d538d'

resource vnet 'Microsoft.Network/virtualNetworks@2024-05-01' = {
  name: vnetName
  location: overridemrgregion
  properties: {
    addressSpace: {
      addressPrefixes: [
        vnetAddressPrefix
      ]
    }
    subnets: [
      {
        name: 'supercomputerNodepoolSubnet'
        properties: {
          addressPrefix: supercomputerNodepoolSubnetPrefix
          serviceEndpoints: [
            {
              service: 'Microsoft.Storage'
            }
          ]
        }
      }
      {
        name: 'aksSubnet'
        properties: {
          addressPrefix: aksSubnetPrefix
          serviceEndpoints: [
            {
              service: 'Microsoft.Storage'
            }
          ]
        }
      }
      {
        name: 'workspaceSubnet'
        properties: {
          addressPrefix: workspaceSubnetPrefix
          delegations: [
            {
              name: 'Microsoft.App.environments'
              properties: {
                serviceName: 'Microsoft.App/environments'
              }
            }
          ]
          serviceEndpoints: [
            {
              service: 'Microsoft.Storage'
            }
          ]
        }
      }
      {
        name: 'privateEndpointSubnet'
        properties: {
          addressPrefix: privateEndpointSubnetPrefix
          defaultOutboundAccess: false
        }
      }
      {
        name: 'agentSubnet'
        properties: {
          addressPrefix: agentSubnetPrefix
          delegations: [
            {
              name: 'Microsoft.App.environments'
              properties: {
                serviceName: 'Microsoft.App/environments'
              }
            }
          ]
          serviceEndpoints: [
            {
              service: 'Microsoft.Storage'
            }
          ]
        }
      }
      {
        name: 'searchSubnet'
        properties: {
          addressPrefix: searchSubnetPrefix
          delegations: [
            {
              name: 'Microsoft.App.environments'
              properties: {
                serviceName: 'Microsoft.App/environments'
              }
            }
          ]
          serviceEndpoints: [
            {
              service: 'Microsoft.Storage'
            }
          ]
        }
      }
    ]
  }
}

resource managedIdentity 'Microsoft.ManagedIdentity/userAssignedIdentities@2024-11-30' = {
  name: managedIdentityName
  location: overridemrgregion
  properties: {
    isolationScope: 'Regional'
  }
}

resource storageAccount 'Microsoft.Storage/storageAccounts@2023-05-01' = {
  name: storageAccountName
  location: overridemrgregion
  kind: 'StorageV2'
  sku: {
    name: storageAccountSku
  }
  dependsOn: [
    vnet
  ]
  properties: {
    accessTier: 'Hot'
    allowBlobPublicAccess: false
    allowSharedKeyAccess: false
    minimumTlsVersion: 'TLS1_2'
    supportsHttpsTrafficOnly: true
    // NOTE: defaultAction is intentionally 'Allow'. 
    networkAcls: {
      defaultAction: 'Allow'
      bypass: 'AzureServices'
      virtualNetworkRules: [
        {
          id: resourceId('Microsoft.Network/virtualNetworks/subnets', vnetName, 'supercomputerNodepoolSubnet')
          action: 'Allow'
        }
        {
          id: resourceId('Microsoft.Network/virtualNetworks/subnets', vnetName, 'aksSubnet')
          action: 'Allow'
        }
        {
          id: resourceId('Microsoft.Network/virtualNetworks/subnets', vnetName, 'workspaceSubnet')
          action: 'Allow'
        }
        {
          id: resourceId('Microsoft.Network/virtualNetworks/subnets', vnetName, 'agentSubnet')
          action: 'Allow'
        }
        {
          id: resourceId('Microsoft.Network/virtualNetworks/subnets', vnetName, 'searchSubnet')
          action: 'Allow'
        }
      ]
    }
  }
}

resource blobServices 'Microsoft.Storage/storageAccounts/blobServices@2023-05-01' = {
  parent: storageAccount
  name: 'default'
  properties: {
    cors: {
      corsRules: [
        {
          allowedOrigins: [
            'https://studio.discovery.microsoft.com'
            'https://*.vscode-cdn.net'
            'https://vscode.dev'
          ]
          allowedMethods: [
            'GET'
            'HEAD'
            'DELETE'
            'PUT'
          ]
          allowedHeaders: [
            '*'
          ]
          exposedHeaders: [
            '*'
          ]
          maxAgeInSeconds: 200
        }
      ]
    }
  }
}

resource blobContainer 'Microsoft.Storage/storageAccounts/blobServices/containers@2023-05-01' = {
  parent: blobServices
  name: blobContainerName
  properties: {
    publicAccess: 'None'
  }
}

resource storageBlobDataContributorAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(storageAccount.id, managedIdentity.id, storageBlobDataContributorRoleId)
  scope: storageAccount
  properties: {
    roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', storageBlobDataContributorRoleId)
    principalId: managedIdentity.properties.principalId
    principalType: 'ServicePrincipal'
  }
}

resource discoveryPlatformContributorAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, managedIdentity.id, discoveryPlatformContributorRoleId)
  properties: {
    roleDefinitionId: subscriptionResourceId(
      'Microsoft.Authorization/roleDefinitions',
      discoveryPlatformContributorRoleId
    )
    principalId: managedIdentity.properties.principalId
    principalType: 'ServicePrincipal'
  }
}

resource acrPullAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, managedIdentity.id, acrPullRoleId)
  properties: {
    roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', acrPullRoleId)
    principalId: managedIdentity.properties.principalId
    principalType: 'ServicePrincipal'
  }
}

resource supercomputer 'Microsoft.Discovery/supercomputers@2026-06-01' = {
  name: supercomputerName
  location: location
  tags: {
    version: 'v2'
    'discovery.overridemrgregion': string(overridemrgregion)
  }
  dependsOn: [
    vnet
  ]
  properties: {
    subnetId: resourceId('Microsoft.Network/virtualNetworks/subnets', vnetName, 'aksSubnet')
    identities: {
      clusterIdentity: {
        id: managedIdentity.id
      }
      kubeletIdentity: {
        id: managedIdentity.id
      }
      workloadIdentities: {
        '${managedIdentity.id}': {}
      }
    }
  }
}

resource nodePool 'Microsoft.Discovery/supercomputers/nodePools@2026-06-01' = {
  parent: supercomputer
  name: nodePoolName
  location: location
  dependsOn: [
    vnet
  ]
  properties: {
    subnetId: resourceId('Microsoft.Network/virtualNetworks/subnets', vnetName, 'supercomputerNodepoolSubnet')
    vmSize: nodePoolVmSize
    maxNodeCount: nodePoolMaxNodeCount
    minNodeCount: nodePoolMinNodeCount
    scaleSetPriority: nodePoolScaleSetPriority
  }
}

resource workspace 'Microsoft.Discovery/workspaces@2026-06-01' = {
  name: workspaceName
  location: location
  tags: {
    version: 'v2'
    'discovery.workbench.enableGhcpAiFeatures': string(enableGhcpAiFeatures)
    'discovery.workbench.enableExtensions': string(enableExtensions)
    'discovery.overridemrgregion': string(overridemrgregion)
    NetworkIsolation: string(networkIsolation)
  }
  dependsOn: [
    vnet
  ]
  properties: {
    workspaceIdentity: {
      id: managedIdentity.id
    }
    supercomputerIds: [
      supercomputer.id
    ]
    agentSubnetId: resourceId('Microsoft.Network/virtualNetworks/subnets', vnetName, 'agentSubnet')
    privateEndpointSubnetId: resourceId('Microsoft.Network/virtualNetworks/subnets', vnetName, 'privateEndpointSubnet')
    workspaceSubnetId: resourceId('Microsoft.Network/virtualNetworks/subnets', vnetName, 'workspaceSubnet')
  }
}

resource chatModelDeployment 'Microsoft.Discovery/workspaces/chatModelDeployments@2026-06-01' = {
  parent: workspace
  name: chatModelDeploymentName
  location: location
  properties: {
    modelFormat: chatModelFormat
    modelName: chatModelName
  }
}

resource discoveryStorageContainer 'Microsoft.Discovery/storageContainers@2026-06-01' = {
  name: storageContainerName
  location: location
  properties: {
    storageStore: {
      kind: 'AzureStorageBlob'
      storageAccountId: storageAccount.id
    }
  }
}

resource project 'Microsoft.Discovery/workspaces/projects@2026-06-01' = {
  parent: workspace
  name: projectName
  location: location
  dependsOn: [
    chatModelDeployment
  ]
  properties: {
    storageContainerIds: [
      discoveryStorageContainer.id
    ]
  }
}

@description('Resource ID of the Supercomputer.')
output supercomputerId string = supercomputer.id

@description('Resource ID of the Node Pool.')
output nodePoolId string = nodePool.id

@description('Resource ID of the Workspace.')
output workspaceId string = workspace.id

@description('Resource ID of the Chat Model Deployment.')
output chatModelDeploymentId string = chatModelDeployment.id

@description('Resource ID of the Discovery Storage Container.')
output storageContainerId string = discoveryStorageContainer.id

@description('Resource ID of the Project.')
output projectId string = project.id

@description('Resource ID of the User-Assigned Managed Identity.')
output managedIdentityId string = managedIdentity.id

@description('Resource ID of the Storage Account.')
output storageAccountId string = storageAccount.id

@description('Resource ID of the Virtual Network.')
output vnetId string = vnet.id

O arquivo Bicep define vários recursos do Azure:

• Microsoft.Network/virtualNetworks - Rede virtual com cinco sub-redes para pool de nós de supercomputadores, AKS, espaço de trabalho, endpoint privado, e tarefas do agente.
• Microsoft. Managed Identity/userAssignedIdentities - Identidade gerida atribuída pelo utilizador para autenticação de supercomputadores e espaços de trabalho.
• Microsoft. Storage/storageAccounts - Armazenamento de Blobs do Azure conta com regras CORS para integrações com Discovery Studio e VS Code.
• Microsoft.Authorization/roleAssignments - Colaborador de Dados de Blob de Armazenamento, Colaborador da Plataforma de Descoberta e atribuições de funções AcrPull para a identidade gerida.
• Microsoft.Discovery/supercomputadores - Recurso de supercomputadores com identidades de cluster, kubelet e carga de trabalho.
• Microsoft. Discovery/supercomputadores/nodePools - Pool de nós configurável com tamanho da VM, número mínimo/máximo de nós e prioridade de escala.
• Microsoft.Discovery/workspaces - Espaço de trabalho ligado ao supercomputador com agente, endpoint privado e sub-redes do espaço de trabalho.
• Microsoft.Discovery/workspaces/chatModelDeployments - Implementação do modelo de chat no espaço de trabalho.
• Microsoft. Discovery/storageContainers - Contentor de armazenamento respaldado pela conta Armazenamento de Blobs do Azure.
• Microsoft. Discovery/workspaces/projects - Projecto ligado ao contentor de armazenamento.

Desdobrar o arquivo Bicep

1. Salve o arquivo Bicep como main.bicep em seu computador local.

2. Substitua os marcadores de posição <prescribedSCName> e <presecribedWSName> pelos nomes do supercomputador e do espaço de trabalho que pretende utilizar. Atualize o location parâmetro se estiver a implementar para uma região diferente de swedencentral.

3. Implante o arquivo Bicep usando a CLI do Azure ou o Azure PowerShell.

   CLI do Azure

   az group create --name exampleRG --location swedencentral
   az deployment group create --resource-group exampleRG --template-file main.bicep --parameters location=swedencentral supercomputerName=<prescribedSCName> workspaceName=<presecribedWSName>
   

   Azure PowerShell

   New-AzResourceGroup -Name exampleRG -Location swedencentral
   New-AzResourceGroupDeployment -ResourceGroupName exampleRG -TemplateFile ./main.bicep -location swedencentral -supercomputerName <prescribedSCName> -workspaceName <presecribedWSName>
   

Quando a implantação for concluída, você verá uma mensagem indicando que a implantação foi bem-sucedida.

Validar a implementação

Utilize o portal do Azure, CLI do Azure ou Azure PowerShell para listar os recursos implantados no grupo de recursos.

CLI do Azure

az resource list --resource-group exampleRG

Azure PowerShell

Get-AzResource -ResourceGroupName exampleRG

Limpeza de recursos

Quando já não precisares dos recursos, usa o portal Azure, CLI do Azure ou Azure PowerShell para eliminar todos os recursos do grupo de recursos.

CLI do Azure

az group delete --name exampleRG

Azure PowerShell

Remove-AzResourceGroup -Name exampleRG

Passos seguintes

Depois de configurar a sua infraestrutura e criar o seu projeto, utilize os seguintes recursos:

• Comece com agentes e sessões partilhadas no Microsoft Discovery Studio
• Consulte as FAQ do Microsoft Discovery para questões comuns sobre implementação, redes, segurança, quotas e limpeza.