Início Rápido: Implantar a infraestrutura do Microsoft Discovery

Neste quickstart, você configura seu ambiente Microsoft Discovery para que possa executar sua primeira investigação científica com IA. Você pode completar a configuração de duas maneiras:

• Portal Azure – Crie cada recurso manualmente por meio de uma experiência guiada e passo a passo. Escolha esse caminho se quiser entender cada componente ou preferir um fluxo de trabalho orientado à interface.
• Bicep – Implante a stack completa com um único modelo de infraestrutura como código. Escolha esse caminho se quiser uma implantação automatizada e repetível.

Ambos os caminhos fornecem os mesmos recursos centrais: rede, identidade, armazenamento, um supercomputador com um pool de nós, um espaço de trabalho com um modelo de implantação de chat, um contêiner de armazenamento e um projeto.

Selecione a aba que corresponder à sua experiência preferida na seção Implantar infraestrutura do Microsoft Discovery.

Pré-requisitos

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

• Uma assinatura ativa do Azure que está habilitada (listada como permitida) para acesso ao Microsoft Discovery. Se sua assinatura ainda não estiver habilitada, entre em contato com seu representante conta Microsoft para solicitar acesso.

• Permissões suficientes na sua assinatura do Azure para registrar provedores de recursos, atribuir funções e criar recursos:

  • A função Proprietário, Administrador de Controle de Acesso Baseado em Funções ou Administrador de Acesso de Usuário é necessária para atribuir funções a administradores (Administradores de Plataforma, Cientistas e Engenheiros) que gerenciam e usam os recursos do Discovery. Para obter a lista completa de funções necessárias, consulte Funções exigidas por persona.

  • Um Contribuidor ou um cargo privilegiado superior (por exemplo, Proprietário) é necessário para registrar provedores de recursos e criar um grupo de recursos.

    Dica

    Para atribuir o conjunto completo de funções da persona Administrador de Plataforma com um único comando idempotente, use o script PowerShell Set-DiscoveryRoleAssignments.ps1 de código aberto. Consulte Atribuir funções de persona do Microsoft Discovery com um script do PowerShell. Esse método é o caminho recomendado para integrar múltiplos usuários.

• Registre os provedores de recursos necessários em sua assinatura. Para obter mais informações, consulte o registro do provedor de recursos. Para se cadastrar Microsoft.Discovery:

  1. Entre no portal do Azure.
  2. Navegue até Assinaturas e escolha sua assinatura.
  3. No menu à esquerda, selecione Provedores de Recursos.
  4. Pesquise por Microsoft.Discovery.
  5. Selecione o nome do provedor e selecione Registrar.

  Note

  Verifique se os provedores de recursos a seguir também estão registrados em sua assinatura. Caso contrário, registre-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

• Atribua a função de Conexão de Perímetro NSP de Descoberta. Os espaços de trabalho, as bibliotecas e os supercomputadores do Microsoft Discovery são reforçados pela rede por padrão usando regras do Perímetro de Segurança de Rede (NSP). Antes de criar seu primeiro workspace, bookshelf ou supercomputer, você deve criar a função personalizada Discovery NSP Perimeter Joiner. Após a criação, atribua a função personalizada Conexão de Perímetro NSP de Descoberta e a função Leitor ao aplicativo de serviço do plano de controle de Descoberta (a entidade de serviço primária) para que o plano de controle possa configurar os Perímetros de Segurança de Rede em sua assinatura. Para obter instruções passo a passo, consulte Atribui a função de Unificador de Perímetro NSP.

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

• Um grupo de recursos existente ou permissões para criar um novo. A criação de um grupo de recursos requer a função Colaborador na assinatura.

Importante

Os recursos do Microsoft Discovery têm suporte em três regiões de produção: East US, Sweden Central e UK South. Para simplificar, crie todos os recursos para uma única implantação na mesma região, assinatura e grupo de recursos.

Note

Você pode associar uma rede virtual a apenas um espaço de trabalho do Microsoft Discovery. Se você precisar de vários workspaces, crie uma rede virtual separada e sub-redes para cada um deles.

Importante

Se você implantar os recursos de rede em um grupo de recursos separado dos outros recursos do Discovery, certifique-se de atribuir a si mesmo as permissões apropriadas no grupo de recursos da rede virtual para que o recurso do supercomputador seja implantado com sucesso. As permissões a serem consideradas são Contribuinte de Rede e Administrador da Plataforma de Descoberta Microsoft (Prévia). Se você usar o modelo Bicep, atualize-o para criar a rede virtual nesse grupo de recursos separado.

Dica

Você pode implantar recursos do Discovery com isolamento total da rede. Quando networkIsolation está ativado, todos os recursos são protegidos dentro da rede privada e são acessíveis apenas pelo endpoint privado e pelo Perímetro de Segurança de Rede (NSP). Você ainda pode acessar o espaço de trabalho pela 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 seu espaço de trabalho e crie endpoints privados para os recursos do workspace. Para orientações, veja Configurar segurança de rede para espaços de trabalho do Microsoft Discovery.

Implantar a infraestrutura do Microsoft Discovery

Selecione a guia Portal do Azure para criar cada recurso manualmente ou a guia Bicep para implantar a pilha completa usando um modelo de infraestrutura como código.

Portal do Azure

Use o portal do Azure para criar cada recurso do Microsoft Discovery por meio de uma experiência guiada.

1. Configurar rede, identidade e armazenamento

Antes de prosseguir com a implantação de componentes de infraestrutura do Microsoft Discovery, use um grupo de recursos existente ou crie um novo.

a. Atribuir funções aos administradores

Dica

Em vez de atribuir as funções listadas abaixo um por um por meio do portal Azure, você pode atribuir a função de persona de Administrador de Plataforma completa definida em um único comando idempotente usando o script do PowerShell de software Set-DiscoveryRoleAssignments.ps1 livre. Consulte Atribuir funções de persona do Microsoft Discovery com um script do PowerShell. Esse é o caminho recomendado para integrar vários usuários.

Atribua as seguintes funções internas aos usuários no escopo desejado (assinatura ou grupo de recursos):

• Administrador da Plataforma de Descoberta de Microsoft (versão prévia)
• Contribuidor de Identidade Gerenciada
• Operador de Identidade Gerenciada
• Contribuidor da Conta de Armazenamento
• Colaborador de Dados do Storage Blob
• Colaborador de rede
• ACRPush
• Usuário do Foundry
• Microsoft Discovery Estante de livros Leitor de Dados de Índice - Versão prévia

Note

Se você estiver atribuindo todas as funções no nível da assinatura, você pode ignorar esta nota. Se você estiver atribuindo funções no nível do grupo de recursos, ignore a função de Usuário do Foundry por enquanto. Continue com as próximas etapas e reveja essa atribuição de função depois que o recurso do workspace for criado. Essa função deve ser atribuída a cada usuário com a função de Administrador da Plataforma ou Cientista no nível do grupo de recursos gerenciados do workspace.

Etapas para atribuir funções:

1. Entre no portal do Azure.
2. Navegue até Assinaturas e escolha sua assinatura.
3. No menu à esquerda, selecione Controle de acesso (IAM).
4. Selecione Adicionar e Adicionar atribuição de função.
5. No painel Adicionar atribuição de função , pesquise cada função uma de cada vez e selecione Avançar.
6. Na guia Membros , verifique se a atribuição de acesso está definida como Usuário, grupo ou entidade de serviço.
7. Selecione + Selecionar membros, escolha os membros aos quais atribuir essa permissão e selecione Avançar.
8. Na guia Condições , selecione Permitir que o usuário atribua todas as funções, exceto funções de administrador privilegiadas Proprietário, UAA, RBAC (Recomendado) e selecione Avançar.
9. Na guia Tipo de Atribuição , selecione a configuração mais adequada à sua organização e selecione Avançar.
10. Na guia Examinar + atribuir , verifique as informações e selecione Examinar + atribuir.

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

b. Criar uma rede virtual e sub-redes

1. Entre no portal do Azure.
2. Pesquise redes virtuais e selecione-as nos resultados.
3. Selecione Criar para começar a criar uma nova rede virtual.
4. Insira detalhes como Assinatura, Grupo de Recursos, Nome e Região e selecione Avançar.
5. Configurar endereços IP:
   • Espaço de endereço IPv4: insira o bloco CIDR (roteamento de Inter-Domain sem classe) 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, você pode remover a default sub-rede da lista.
9. Revise e crie a rede virtual.

Note

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

c. Criar uma identidade gerenciada atribuída pelo usuário (UAMI)

Você pode criar UAMIs diferentes cada uma com suas próprias permissões necessárias para acesso a recursos específicos ou pode criar uma única interface do usuário com todas as permissões necessárias para a plataforma. Para este exercício, crie uma UAMI única seguindo estas etapas:

1. Entre no portal do Azure.
2. Pesquise identidades gerenciadas e selecione-as na lista.
3. Selecione Criar.
4. Preencha os detalhes necessários, como assinatura, grupo de recursos, região e nome.
5. Selecione Examinar + Criar e Criar.

d. Atribua funções ao controle de acesso baseado em função do Azure ao UAMI

Atribua as seguintes funções internas à nova Identidade Gerenciada Atribuída pelo Usuário no nível do Grupo de Recursos:

• Colaborador da plataforma Microsoft Discovery (versão prévia)
• Colaborador de Dados do Storage Blob
• ACRPull

1. Navegue até Assinaturas e escolha sua assinatura.
2. Selecione o grupo de recursos que você está usando para este exercício.
3. No menu à esquerda, selecione Controle de acesso (IAM).
4. Selecione Adicionar e Adicionar atribuição de função.
5. No painel Adicionar atribuição de função , pesquise cada função uma de cada vez e selecione Avançar.
6. Na guia Membros , verifique se a atribuição de acesso está definida como Identidade Gerenciada.
7. Selecione + Selecionar membros. No painel Selecionar identidades gerenciadas , selecione sua assinatura, selecione o tipo de identidade gerenciada atribuído pelo usuário , selecione a identidade gerenciada que você criou na etapa anterior e selecione Selecionar.
8. Na guia Examinar + atribuir , verifique todas as informações e selecione Examinar + atribuir.

e. Criar uma conta Armazenamento de Blobs do Azure

Para armazenar dados de entrada e saída para suas investigações, crie uma conta de armazenamento de blobs Azure para associar ao contêiner de armazenamento ou use uma existente com os seguintes requisitos:

• Crie um contêiner dentro da conta de armazenamento chamada discoveryoutputs onde os arquivos de saída são armazenados.
• A conta de armazenamento deve permitir o acesso da Rede Virtual usada para criar o supercomputador e o workspace.
• A conta de armazenamento deve permitir o acesso do IP público do cliente ou da rede local para que você possa acessar os dados de saída.
• A conta de armazenamento deve ter as configurações corretas do CORS. Você deve permitir estas origens: https://studio.discovery.microsoft.com, https://vscode.deve https://*.vscode-cdn.net. Defina as operações permitidas para incluir GET, HEAD, DELETE e PUT, defina Allowed Headers e Exposed Headers para * e Max Age para 200. Essa configuração é encontrada na página cors (compartilhamento de recursos) na guia Configurações .
• Verifique se a conta de armazenamento tem Storage Blob Data Contributor acesso ao UAMI criado na etapa anterior.

Para criar uma conta de armazenamento de blobs Azure:

1. Entre no portal do Azure.
2. Pesquise contas de armazenamento e selecione-as nos resultados.
3. Selecione Criar para começar a criar uma nova conta de armazenamento.
4. Insira detalhes como Assinatura, Grupo de Recursos, Nome e Região.
5. Selecione Armazenamento de Blobs do Azure como o serviço primário e selecione a guia Networking.
6. Em acesso à rede pública, selecione Habilitar acesso público em 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 cliente se você estiver acessando dados pela Internet ou verifique se o cliente pode acessar a conta de armazenamento e a rede virtual por meio de link privado, VPN Site a Site ou ExpressRoute.
9. Selecione Examinar + criar e, em seguida, selecione Criar.

Note

Para exibir e baixar arquivos de saída, seu cliente ou navegador precisa de acesso à rede para o armazenamento de blobs. Você pode permitir o acesso público à Internet abrindo o acesso público a todas as redes. Você também pode permitir o endereço IP público do cliente nas configurações de rede de armazenamento e firewall. Como alternativa, configure o acesso privado por meio de Azure VPN ou ExpressRoute.

Criar um contêiner de blob

1. Depois que a conta de armazenamento for criada, navegue até a página de visão geral da conta de armazenamento.
2. No painel de navegação esquerdo, em Armazenamento de dados, selecione Contêineres.
3. Selecione Adicionar contêiner.
4. Insira discoveryoutputs como o nome e selecione Criar.

Habilitar o acesso ao CORS e UAMI

1. Abra a conta de armazenamento que criamos na etapa anterior.
2. Na guia Configurações, selecione CORS (Compartilhamento de Recursos).
3. Em serviço Blob, na coluna Origens permitidas, insira 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, , DELETEe OPTIONSPUT. Defina Allowed Headers e Exposed Headers para *, e Max Age para 200.
4. Selecione Salvar.

2. Criar um supercomputador

Você precisa de um supercomputador com pools de nós associados para implantar e executar ferramentas científicas e indexar seus dados nas bases de dados de conhecimento da Bookshelf. O supercomputador também executa cargas de trabalho intensivas de GPU e CPU para simulação e modelagem. Ele fornece os recursos de computação em uma rede virtual específica em sua assinatura.

1. Entre no portal do Azure.
2. Pesquise Supercomputadores de Descoberta da Microsoft.
3. Selecione Criar e insira detalhes como ID da Assinatura, Nome do Grupo de Recursos, Local e Nome e selecione Avançar.
4. Na aba de Rede , selecione a rede virtual e aksSubnet que você criou no passo 1, e então selecione Próximo.
5. Na guia SKU do Sistema, selecione Standard_D4s_v6 como o SKU do Sistema para essa implantação e selecione Avançar.
6. Na aba Identidades , adicione a identidade gerenciada atribuída pelo usuário (UAMI) que você criou no passo 1 para a identidade do cluster, identidade kubelet e identidade da carga de trabalho. Instâncias de supercomputador usam essa identidade gerenciada para acessar dados de seus recursos de Azure. Ao terminar, selecione Avançar.
7. Na guia Encryption, já que estamos usando chaves gerenciadas por Microsoft para este exercício, uncheck a opção "Habilitar Chaves Gerenciadas pelo Cliente" e selecione Next.
8. Adicione etiquetas conforme necessário e vá para a próxima guia.
9. Examine os Termos e Condições e selecione Avançar.
10. Depois que a validação for bem-sucedida, selecione Criar.

3. Criar pools de node

Depois que o supercomputador for criado, siga estas etapas para criar um pool de nós:

1. Abra o Supercomputador que criamos na etapa anterior.
2. No painel esquerdo, selecione Pool de nós em Configurações e, em seguida, selecione Criar.
3. Insira o nome e o local do pool de nós e selecione Avançar.

   Note

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

4. Na aba Rede , selecione a rede virtual e supercomputerNodepoolSubnet aquela que você criou no passo 1, e selecione Próximo. Nota: Use a mesma rede virtual selecionada para o supercomputador na etapa 2.
5. Na guia configuração da VM , selecione a SKU da VM (Máquina Virtual) a ser usada para o pool de nós e selecione Avançar. A SKU e a cota selecionadas devem estar disponíveis na região em que você implanta o pool de nós.
6. Na seção Dimensionamento , insira a contagem máxima de nós para a qual o pool de nós pode ser dimensionado, por exemplo: 5 e selecione Avançar.
7. Selecione Examinar + criar e Criar.

4. Criar um espaço de trabalho

Um workspace é um ambiente colaborativo em que as equipes gerenciam iniciativas científicas em larga escala. Os espaços de trabalho reúnem os recursos de infraestrutura, como supercomputadores, agentes, ferramentas e bases de conhecimento (Prateleiras) em um único limite seguro. Você pode criar projetos em workspaces, permitindo que os pesquisadores organizem experimentos, analisem dados e usem agentes de IA em um espaço compartilhado.

Importante

Verifique se o nome do workspace é globalmente exclusivo e usa apenas letras minúsculas.

1. Entre no portal do Azure.

2. Pesquise por Espaços de Trabalho de Descoberta da Microsoft.

3. Selecione + Criar e insira detalhes como Assinatura, Grupo de Recursos, Nome e Região e selecione Avançar.

4. Na aba Rede , selecione Acesso à Rede Pública como Habilitar para este exercício. Depois disso, insira os detalhes da sub-rede Private Endpoint, sub-rede Agente e sub-rede Workspace com as sub-redes que você criou anteriormente no passo 1, e então selecione Próximo.

5. Na guia Criptografia , deixe a CMK (Habilitar chaves gerenciadas pelo cliente) desmarcada. Para este exercício, usaremos as Chaves Gerenciadas pela Microsoft (MMK); basta selecionar Avançar para ir para a próxima guia.

6. Na guia Supercomputador , selecione Adicionar Supercomputador e selecione sua assinatura, grupo de recursos e o supercomputador criado na etapa 2 e selecione Avançar.

7. Na aba Identidade do Espaço de Trabalho , selecione Adicionar em Identidade Gerenciada Atribuída pelo Usuário (UAMI) e selecione a identidade que você criou na etapa 1 para fornecer acesso ao espaço de trabalho.

8. Na guia Marcas , adicione marcas conforme necessário. (Opcional) Para habilitar GitHub Copilot e configurar o acesso ao workspace, adicione as marcas a seguir. Para obter detalhes, consulte Usar GitHub Copilot no Microsoft Discovery.

   • discovery.workbench.enableGhcpAiFeatures definido para true — habilita o GitHub Copilot e recursos de IA para o espaço de trabalho.
   • discovery.workbench.enableExtensions configurado como true — habilita o Marketplace de Extensões do VS Code na experiência de prévia.
   • NetworkIsolation definido como false – Habilita o acesso público à experiência de visualização (workbench) e a outros recursos do MRG (grupo de recursos gerenciados). Se você mantiver o isolamento de rede habilitado (padrão), será necessário estar conectado em uma VPN ou ExpressRoute à rede virtual em que o workspace é implantado para acessar pela rede privada.

   Dica

   Você pode implantar recursos do Discovery com isolamento total da rede. Quando networkIsolation está ativado, todos os recursos são protegidos dentro da rede privada e são acessíveis apenas pelo endpoint privado e pelo Perímetro de Segurança de Rede (NSP). Você ainda pode acessar o espaço de trabalho pela 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 seu espaço de trabalho e crie endpoints privados para os recursos do workspace. Para orientações, veja Configurar segurança de rede para espaços de trabalho do Microsoft Discovery.

   Note

   As tags são imutáveis para os tipos de recurso do Microsoft Discovery, incluindo espaços de trabalho, supercomputadores, conjuntos de nós e estantes de livros. Depois que um recurso é criado, você não pode adicionar, mudar ou remover suas tags. Qualquer modificação de tag, incluindo adicionar uma tag, requer a reimplantação do recurso.

9. Examine os Termos e Condições e selecione Examinar + Criar.

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

5. Atribuir a função de usuário do Foundry no grupo de recursos gerenciados

Quando um workspace é criado, um grupo de recursos gerenciado é provisionado automaticamente junto com ele. Para permitir que os usuários modifiquem agentes e fluxos de trabalho em um projeto diretamente no portal do Foundry para configurações avançadas, você deve atribuir a eles a função De usuário do Foundry nesse grupo de recursos gerenciado.

1. Entre no portal do Azure.
2. Vá até o espaço de trabalho que você criou no passo 4 e encontre o nome do Grupo de Recursos Gerenciados na página de visão geral do espaço de trabalho.
3. Navegue até esse grupo de recursos gerenciado.
4. No menu à esquerda, selecione Controle de acesso (IAM).
5. Selecione Adicionar e Adicionar atribuição de função.
6. No painel Adicionar atribuição de função , pesquise o Usuário do Foundry e selecione-o e selecione Avançar.
7. Na guia Membros , verifique se a atribuição de acesso está definida como Usuário, grupo ou entidade de serviço.
8. Selecione + Selecionar membros, escolha os usuários que precisam modificar agentes e fluxos de trabalho e selecione Selecionar.
9. Selecione Examinar + atribuir, verificar as informações e selecionar Examinar + atribuir.

Repita esse processo para todos os usuários que precisam de acesso a agentes e fluxos de trabalho no workspace. Todas as alterações feitas no portal do Foundry diretamente são refletidas na configuração do agente de descoberta automaticamente.

6. Criar implantação de modelo de chat

As implantações de modelos de chat fornecem modelos fundamentais de linguagem como o GPT-5.4 para uso dentro do Microsoft Discovery Workspace. Os agentes criados em projetos podem usar essas implantações de modelo de chat.

1. Vá para a página de visão geral do workspace Microsoft Discovery, criado na etapa anterior.

2. Na guia Configurações no painel de navegação esquerdo, selecione Implantações de Modelo 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. Em seguida, selecione o botão Examinar + criar na parte inferior e selecione Criar.

   

Importante

Para usar o Discovery Engine e tarefas em suas sessões, você deve usar esta implantação específica com o nome gpt-5-4 e o nome do modelo gpt-5.4. No entanto, você pode ter implantações adicionais de modelos de chat para uso com agentes.

Você pode fornecer acesso para os usuários por meio de Controle de Acesso Baseado em Funções (RBAC) no nível do grupo de recursos. Função de Administrador de Descoberta do Microsoft (Versão Prévia) é necessária para criar projetos em um espaço de trabalho.

7. Faça login no Microsoft Discovery Studio

Microsoft Discovery Studio é um ambiente de pesquisa seguro e alimentado por IA. Ele permite que cientistas e engenheiros acelerem a inovação por meio de agentes autônomos, fluxos de trabalho de simulação e ferramentas de dados integradas em uma interface unificada.

Depois que sua infraestrutura for configurada, você poderá entrar no Microsoft Discovery Studio diretamente por meio da URL ou encontrar a URL na página de visão geral do Workspace no portal Azure.

Você deve fazer login com suas credenciais do Microsoft Entra ID para sua conta de trabalho ou escola. O Studio suporta login único com o Microsoft Entra ID. Você não precisa fornecer credenciais explicitamente se já estiver logado em outro serviço com seu Microsoft Entra ID no mesmo navegador.

Note

Se você tiver acesso a vários locatários Microsoft Entra, selecione o locatário certo selecionando o ícone de perfil no canto superior direito da página.

8. (Opcional) Criar um contêiner de armazenamento independente

Todo projeto exige um contêiner de armazenamento. A forma recomendada de provisioná-lo é selecionar Criar um contêiner de armazenamento para mim durante a criação do projeto no passo 9. Siga essa etapa apenas se quiser criar e gerenciar um contêiner de armazenamento independente — por exemplo, para reutilizar um contêiner em vários projetos.

Os contêineres de armazenamento armazenam dados de entrada e saída como ativos de armazenamento. As entradas e as saídas usam um contêiner 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 sob Recursos, selecione Dados.
2. Selecione Criar Contêiner.
3. Insira detalhes como nome, assinatura, grupo de recursos e localização.
4. Selecione a conta de armazenamento criada na etapa 1.
5. Selecione Criar.
6. Quando você cria o projeto, pode selecionar esse contêiner de armazenamento.

Note

Depois de selecionar Criar, o recurso estará inicialmente no estado Aceito . Atualize a página e aguarde até que o Estado de Provisionamento seja alterado para Bem-sucedido antes de continuar. Essa operação normalmente leva alguns minutos.

9. Criar um projeto

Os projetos ajudam você a organizar e gerenciar investigações científicas em um workspace. Cada projeto define o limite funcional para acesso a seus agentes, ferramentas e contêineres de armazenamento. Em um projeto, você pode executar experimentos, analisar dados, aplicar modelos de IA e acompanhar o progresso da pesquisa em um ambiente colaborativo.

Importante

O nome do projeto deve ter todas as letras minúsculas e não mais do que 12 caracteres. Além disso, certifique-se de atualizar a página antes de criar um projeto. Você pode criar um projeto abrindo seu espaço de trabalho no estúdio.

1. No Microsoft Discovery Studio, no painel de navegação à esquerda, selecione Workspaces. Aqui estão todos os espaços de trabalho existentes em suas assinaturas do Azure.

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

3. Selecione Criar Projeto.

4. Insira um nome para o projeto.

5. Mantenha a opção Criar um contêiner de armazenamento para mim ativada.

6. Em Selecionar Conta de Armazenamento, selecione a conta de armazenamento que você criou no passo 1. Um novo contêiner de armazenamento é criado para o projeto.

   Note

   A opção Criar um container de armazenamento para mim cria um novo recurso de container de armazenamento no mesmo grupo de recursos do seu workspace e projeto. Esse método é a forma recomendada de provisionar o contêiner de armazenamento que um projeto exige. Para criar e gerenciar contêineres de armazenamento independentes para outros cenários, use o passo 8.

   

   

7. Selecione Criar.

Note

Depois de selecionar Criar, o projeto estará inicialmente no estado Aceito . Atualize a página e aguarde até que o Estado de Provisionamento seja alterado para Bem-sucedido antes de continuar.

Bicep

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

Bicep é uma linguagem específica de domínio (DSL) que usa sintaxe declarativa para implantar recursos do Azure. Ele fornece sintaxe concisa, segurança de tipos confiá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

Este início rápido usa um arquivo Bicep dos Modelos de Início Rápido do Azure.

Neste guia de início rápido, você implanta a pilha completa do Microsoft Discovery na Suécia Central. A implantação cria uma rede virtual com um espaço de endereço 10.0.0.0/16 e cinco sub-redes para pools de nós de supercomputador, AKS, workspace, pontos de extremidade privados e agentes. A implantação prevê uma conta de armazenamento Standard_LRS com regras CORS ativadas para Discovery Studio e VS Code. Cria uma identidade gerenciada atribuída pelo usuário com as atribuições de função Storage Blob Data Contributor, Discovery Platform Contributor e AcrPull. Os recursos centrais do Discovery incluem um supercomputador com um pool de nós Standard_D4s_v6 (escalando de 0 a 3 nós), um espaço de trabalho com uma implantação de modelo de chat, um contêiner de armazenamento e um projeto.

Note

Ative o Workbench unificado (prévia). O Workbench unificado, que inclui GitHub Copilot e recursos de IA, está em versão prévia. Para habilitá-lo, implante seu espaço de trabalho com as tags discovery.workbench.enableGhcpAiFeatures: true e discovery.workbench.enableExtensions: true. A forma como você acessa a Bancada depende da configuração do espaço de trabalho networkIsolation:

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

Para mais informações, veja Use o GitHub Copilot no Microsoft Discovery.

Note

As tags são imutáveis para os tipos de recurso do Microsoft Discovery, incluindo espaços de trabalho, supercomputadores, conjuntos de nós e estantes de livros. Depois que um recurso é criado, você não pode adicionar, mudar ou remover suas tags. Defina todas as tags necessárias no template antes de implantar; Qualquer modificação de tag, incluindo adicionar uma tag, 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 o pool de nós do supercomputador, AKS, espaço de trabalho, ponto de extremidade privado e cargas de trabalho do agente.
• Microsoft. ManagedIdentity/userAssignedIdentities – identidade gerenciada atribuída pelo usuário para autenticação de supercomputador e workspace.
• Microsoft. Storage/storageAccounts - Armazenamento de Blobs do Azure conta com regras CORS para integrações do Discovery Studio e do VS Code.
• Microsoft.Authorization/roleAssignments — Atribuições de função de Colaborador de Dados de Blob de Armazenamento, Colaborador da Plataforma do Discovery e AcrPull para a identidade gerenciada.
• Microsoft.Discovery/supercomputadores – recurso de supercomputador com identidades de cluster, kubelet e carga de trabalho.
• Microsoft.Discovery/supercomputers/nodePools — Pool de nós configurável com tamanho de VM, contagem mínima/máxima de nós e prioridade do conjunto de dimensionamento.
• Microsoft.Discovery/workspaces — Espaço de trabalho vinculado ao supercomputador com agente, ponto de extremidade privado e sub-redes do espaço de trabalho.
• Microsoft.Discovery/workspaces/chatModelDeployments – A implantação do modelo de chat no workspace.
• Microsoft. Discovery/storageContainers – contêiner de armazenamento apoiado pela conta Armazenamento de Blobs do Azure.
• Microsoft.Discovery/workspaces/projects - Projeto vinculado ao contêiner de armazenamento.

Implante o arquivo Bicep

1. Salve o arquivo Bicep como main.bicep no computador local.

2. Substitua os <prescribedSCName> e <presecribedWSName> marcadores pelos nomes do supercomputador e do espaço de trabalho que você quer usar. Atualize o parâmetro location se você estiver implantando em 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, uma mensagem será exibida indicando que a implantação foi realizada com sucesso.

Validar a implementação

Use o portal do Azure, a CLI do Azure ou o 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

Limpar os recursos

Quando você não precisar mais dos recursos, use o portal Azure, CLI do Azure ou Azure PowerShell para excluir todos os recursos do grupo de recursos.

CLI do Azure

az group delete --name exampleRG

Azure PowerShell

Remove-AzResourceGroup -Name exampleRG

Próximas Etapas 

Depois de configurar sua infraestrutura e criar seu projeto, use os seguintes recursos:

• Introdução a agentes e sessões compartilhadas no Microsoft Discovery Studio
• Revise o FAQ do Microsoft Discovery para dúvidas comuns sobre implantação, rede, segurança, cotas e limpeza.