Usar perfis de versão de API com go no Hub de Azure StackUse API version profiles with Go in Azure Stack Hub

Perfis de versão e do GoGo and version profiles

Um perfil é uma combinação de diferentes tipos de recursos com versões diferentes de serviços diferentes.A profile is a combination of different resource types with different versions from different services. O uso de um perfil ajuda você a misturar e corresponder entre diferentes tipos de recursos.Using a profile helps you mix and match between different resource types. Os perfis podem fornecer os seguintes benefícios:Profiles can provide the following benefits:

  • Estabilidade para seu aplicativo bloqueando para versões específicas da API.Stability for your app by locking to specific API versions.
  • Compatibilidade para seu aplicativo com Azure Stack Hub e datacenters do Azure regionais.Compatibility for your app with Azure Stack Hub and regional Azure datacenters.

No SDK do Go, os perfis estão disponíveis no caminho de perfis.In the Go SDK, profiles are available under the profiles path. Os números de versão do perfil são rotulados no formato aaaa-mm-dd .Profile version numbers are labeled in the YYYY-MM-DD format. A versão mais recente do perfil da API do Hub Azure Stack é 2019-03-01 para versões do hub Azure Stack 1904 ou posterior.The latest Azure Stack Hub API profile version is 2019-03-01 for Azure Stack Hub versions 1904 or later. Para importar um determinado serviço de um perfil, importe o módulo correspondente do perfil.To import a given service from a profile, import its corresponding module from the profile. Por exemplo, para importar o serviço de computação do perfil 2019-03-01 , use o seguinte código:For example, to import Compute service from 2019-03-01 profile, use the following code:

import "github.com/Azure/azure-sdk-for-go/profiles/2019-03-01/compute/mgmt/compute"

Instale o SDK do Azure para linguagem GoInstall the Azure SDK for Go

  1. Instale o git.Install Git. Para obter instruções, consulte introdução-instalando o Git.For instructions, see Getting Started - Installing Git.

  2. Instale a linguagem de programação go.Install the Go programming language. Os perfis de API do Azure requerem a versão 1,9 ou mais recente do go.API profiles for Azure require Go version 1.9 or newer.

  3. Instale o SDK do Azure Go e suas dependências executando o seguinte comando bash:Install the Azure Go SDK and its dependencies by running the following bash command:

    go get -u -d github.com/Azure/azure-sdk-for-go/...
    

O SDK do GoThe Go SDK

Você pode encontrar mais informações sobre o SDK do Azure go nos seguintes links:You can find more information about the Azure Go SDK at the following links:

Dependências de Go-AutoRestGo-AutoRest dependencies

O SDK go depende dos módulos do Azure go-autorest para enviar solicitações REST para Azure Resource Manager pontos de extremidade.The Go SDK depends on the Azure Go-AutoRest modules to send REST requests to Azure Resource Manager endpoints. Você deve importar as dependências do módulo Azure go-autorest do Azure Go-AutoRest no GitHub.You must import the Azure Go-AutoRest module dependencies from Azure Go-AutoRest on GitHub. Você pode encontrar os comandos de instalação bash na seção instalar .You can find the install bash commands in the Install section.

Como usar perfis do SDK go no Hub de Azure StackHow to use Go SDK profiles on Azure Stack Hub

Para executar um exemplo de código go no Hub Azure Stack, siga estas etapas:To run a sample of Go code on Azure Stack Hub, follow these steps:

  1. Instale o SDK do Azure para linguagem Go e suas dependências.Install the Azure SDK for Go and its dependencies. Para obter instruções, consulte a seção anterior, instalar SDK do Azure para linguagem go.For instructions, see the previous section, Install Azure SDK for Go.

  2. Obtenha as informações de metadados do ponto de extremidade do Resource Manager.Get the metadata info from the Resource Manager endpoint. O ponto de extremidade retorna um arquivo JSON com as informações necessárias para executar o código go.The endpoint returns a JSON file with the info required to run your Go code.

    Observação

    O ResourceManagerUrl no kit de desenvolvimento do Azure Stack (ASDK) é: https://management.local.azurestack.external/The ResourceManagerUrl in the Azure Stack Development Kit (ASDK) is: https://management.local.azurestack.external/
    O ResourceManagerUrl em sistemas integrados é: https://management.<region>.<fqdn>/The ResourceManagerUrl in integrated systems is: https://management.<region>.<fqdn>/
    Para recuperar os metadados necessários: <ResourceManagerUrl>/metadata/endpoints?api-version=1.0To retrieve the metadata required: <ResourceManagerUrl>/metadata/endpoints?api-version=1.0

    Arquivo JSON de exemplo:Sample JSON file:

    { "galleryEndpoint": "https://portal.local.azurestack.external:30015/",  
      "graphEndpoint": "https://graph.windows.net/",  
      "portal Endpoint": "https://portal.local.azurestack.external/",
      "authentication": {
        "loginEndpoint": "https://login.windows.net/",
        "audiences": ["https://management.<yourtenant>.onmicrosoft.com/3cc5febd-e4b7-4a85-a2ed-1d730e2f5928"]
      }
    }
    
  3. Se não estiver disponível, crie uma assinatura e salve a ID da assinatura a ser usada posteriormente.If not available, create a subscription and save the subscription ID to be used later. Para obter informações sobre como criar uma assinatura, consulte criar assinaturas para ofertas no Hub Azure Stack.For info on creating a subscription, see Create subscriptions to offers in Azure Stack Hub.

  4. Crie uma entidade de serviço que usa um segredo do cliente, com o escopo da assinatura e a função de proprietário .Create a service principal that uses a client secret, with Subscription scope and Owner role. Salve a ID da entidade de serviço e o segredo.Save the service principal ID and secret. Para obter informações sobre como criar uma entidade de serviço para Azure Stack Hub, consulte usar uma identidade de aplicativo para acessar recursos.For information about creating a service principal for Azure Stack Hub, see Use an app identity to access resources. Seu ambiente de Hub de Azure Stack agora está configurado.Your Azure Stack Hub environment is now set up.

  5. Importe um módulo de serviço do perfil do SDK Go em seu código.Import a service module from the Go SDK profile in your code. A versão atual do perfil do Hub do Azure Stack é 2019-03-01.The current version of Azure Stack Hub profile is 2019-03-01. Por exemplo, para importar um módulo de rede do tipo de perfil 2019-03-01 , use o seguinte código:For example, to import a network module from the 2019-03-01 profile type, use the following code:

    package main
     import "github.com/Azure/azure-sdk-for-go/profiles/2019-03-01/network/mgmt/network"
    
  6. Em sua função, crie e autentique um cliente com uma nova chamada de função de cliente.In your function, create and authenticate a client with a New client function call. Para criar um cliente de rede virtual, use o seguinte código:To create a virtual network client, use the following code:

    package main
    
    import "github.com/Azure/azure-sdk-for-go/profiles/2019-03-01/network/mgmt/network"
    
    func main() {
       vnetClient := network.NewVirtualNetworksClientWithBaseURI("<baseURI>", "(subscriptionID>")
       vnetClient.Authorizer = autorest.NewBearerAuthorizer(token)
    

    Defina <baseURI> como o valor ResourceManagerUrl usado na etapa 2.Set <baseURI> to the ResourceManagerUrl value used in step 2. Defina <subscriptionID> para o valor SubscriptionId salvo na etapa 3.Set <subscriptionID> to the SubscriptionID value saved from step 3.

    Para criar o token, consulte a próxima seção.To create the token, see the next section.

  7. Invoque métodos de API usando o cliente que você criou na etapa anterior.Invoke API methods by using the client that you created in the previous step. Por exemplo, para criar uma rede virtual usando o cliente da etapa anterior, consulte o exemplo a seguir:For example, to create a virtual network by using the client from the previous step, see the following example:

    package main
    
    import "github.com/Azure/azure-sdk-for-go/profiles/2019-03-01/network/mgmt/network"
    func main() {
    vnetClient := network.NewVirtualNetworksClientWithBaseURI("<baseURI>", "(subscriptionID>")
    vnetClient .Authorizer = autorest.NewBearerAuthorizer(token)
    
    vnetClient .CreateOrUpdate( )
    

Para obter um exemplo completo de como criar uma rede virtual no Hub Azure Stack usando o perfil do SDK Go, consulte o exemplo.For a complete example of creating a virtual network on Azure Stack Hub by using the Go SDK profile, see the example.

AutenticaçãoAuthentication

Para obter a propriedade do autorizador de Azure Active Directory usando o SDK do Go, instale os módulos Go-My REST .To get the Authorizer property from Azure Active Directory using the Go SDK, install the Go-AutoRest modules. Esses módulos já devem ter sido instalados com a instalação do "go SDK".These modules should have been already installed with the "Go SDK" installation. Se não estiverem, instale o pacote de autenticação do GitHub.If they aren't, install the authentication package from GitHub.

O autorizador deve ser definido como o autorizador para o cliente do recurso.The Authorizer must be set as the authorizer for the resource client. Há diferentes maneiras de obter tokens do autorizador no Hub Azure Stack usando as credenciais do cliente:There are different ways to get authorizer tokens on Azure Stack Hub by using client credentials:

  1. Se uma entidade de serviço com a função de proprietário na assinatura estiver disponível, ignore esta etapa.If a service principal with owner role on the subscription is available, skip this step. Caso contrário, consulte usar uma identidade de aplicativo para acessar recursos para obter instruções sobre como criar uma entidade de serviço que usa um segredo do cliente e para obter ajuda sobre como atribuir uma função de "proprietário" com escopo à sua assinatura.Otherwise, see Use an app identity to access resources for instructions on creating a service principal that uses a client secret, and for help on how to assign it an "owner" role scoped to your subscription. Certifique-se de capturar a ID do aplicativo da entidade de serviço e o segredo.Be sure to capture the service principal application ID and secret.

  2. Importe o pacote Adal de go-autorest em seu código.Import the adal package from Go-AutoRest in your code.

    package main
    import "github.com/Azure/go-autorest/autorest/adal"
    
  3. Crie um oauthConfig usando o método NewOAuthConfig do módulo Adal .Create an oauthConfig by using NewOAuthConfig method from adal module.

    package main
    
    import "github.com/Azure/go-autorest/autorest/ada1"
    
    func CreateToken() (adal.OAuthTokenProvider, error) {
       var token adal.OAuthTokenProvider
       oauthConfig, err := adal.NewOAuthConfig(activeDirectoryEndpoint, tenantID)
    }
    

    Defina <activeDirectoryEndpoint> como o valor da loginEndpoint propriedade dos ResourceManagerUrl metadados recuperados na seção anterior deste documento.Set <activeDirectoryEndpoint> to the value of the loginEndpoint property from the ResourceManagerUrl metadata retrieved on the previous section of this document. Defina o <tenantID> valor para sua ID de locatário do hub de Azure Stack.Set the <tenantID> value to your Azure Stack Hub tenant ID.

  4. Por fim, crie um token de entidade de serviço usando o NewServicePrincipalToken método do módulo Adal :Finally, create a service principal token by using the NewServicePrincipalToken method from the adal module:

    package main
    
    import "github.com/Azure/go-autorest/autorest/adal"
    
    func CreateToken() (adal.OAuthTokenProvider, error) {
        var token adal.OAuthTokenProvider
        oauthConfig, err := adal.NewOAuthConfig(activeDirectoryEndpoint, tenantID)
        token, err = adal.NewServicePrincipalToken(
            *oauthConfig,
            clientID,
            clientSecret,
            activeDirectoryResourceID)
        return token, err
    

    Defina <activeDirectoryResourceID> como um dos valores na lista "audiência" dos metadados ResourceManagerUrl recuperados na seção anterior deste artigo.Set <activeDirectoryResourceID> to one of the values in the "audience" list from the ResourceManagerUrl metadata retrieved in the previous section of this article. Defina <clientID> como a ID do aplicativo da entidade de serviço salva quando a entidade de serviço foi criada na seção anterior deste artigo.Set <clientID> to the service principal application ID saved when the service principal was created in the previous section of this article. Defina <clientSecret> como o segredo do aplicativo da entidade de serviço salvo quando a entidade de serviço foi criada na seção anterior deste artigo.Set <clientSecret> to the service principal application secret saved when the service principal was created in the previous section of this article.

ExemploExample

Este exemplo mostra um exemplo de código go que cria uma rede virtual no Hub Azure Stack.This example shows a sample of Go code that creates a virtual network on Azure Stack Hub. Para obter exemplos completos do SDK Go, consulte o repositório Azure go SDK Samples.For complete examples of the Go SDK, see the Azure Go SDK samples repository. Os exemplos de Hub de Azure Stack estão disponíveis no caminho híbrido dentro das pastas de serviço do repositório.Azure Stack Hub samples are available under the hybrid path inside service folders of the repository.

Observação

Para executar o código neste exemplo, verifique se a assinatura usada tem o provedor de recursos de rede listado como registrado.To run the code in this example, verify that the subscription used has the Network resource provider listed as Registered. Para verificar, procure a assinatura no portal do hub de Azure Stack e selecione provedores de recursos.To verify, look for the subscription in the Azure Stack Hub portal, and select Resource providers.

  1. Importe os pacotes necessários em seu código.Import the required packages in your code. Use o perfil mais recente disponível no Hub de Azure Stack para importar o módulo de rede:Use the latest available profile on Azure Stack Hub to import the network module:

    package main
    
    import (
        "context"
        "fmt"
        "github.com/Azure/azure-sdk-for-go/profiles/2019-03-01/network/mgmt/network"
        "github.com/Azure/go-autorest/autorest"
        "github.com/Azure/go-autorest/autorest/adal"
        "github.com/Azure/go-autorest/autorest/to"
    )
    
  2. Defina suas variáveis de ambiente.Define your environment variables. Para criar uma rede virtual, você deve ter um grupo de recursos.To create a virtual network, you must have a resource group.

    var (
        activeDirectoryEndpoint = "yourLoginEndpointFromResourceManagerUrlMetadata"
        tenantID = "yourAzureStackTenantID"
        clientID = "yourServicePrincipalApplicationID"
        clientSecret = "yourServicePrincipalSecret"
        activeDirectoryResourceID = "yourAudienceFromResourceManagerUrlMetadata"
        subscriptionID = "yourSubscriptionID"
        baseURI = "yourResourceManagerURL"
        resourceGroupName = "existingResourceGroupName"
    )
    
  3. Agora que você definiu suas variáveis de ambiente, adicione um método para criar um token de autenticação usando o pacote Adal .Now that you've defined your environment variables, add a method to create an authentication token by using the adal package. Para obter mais informações sobre autenticação, consulte a seção anterior.For more info on authentication, see the previous section.

    //CreateToken creates a service principal token
    func CreateToken() (adal.OAuthTokenProvider, error) {
       var token adal.OAuthTokenProvider
       oauthConfig, err := adal.NewOAuthConfig(activeDirectoryEndpoint, tenantID)
       token, err = adal.NewServicePrincipalToken(
           *oauthConfig,
           clientID,
           clientSecret,
           activeDirectoryResourceID)
       return token, err
    }
    
  4. Adicione o método main.Add the main method. O main método obtém primeiro um token usando o método definido na etapa anterior.The main method first gets a token by using the method that is defined in the previous step. Em seguida, ele cria um cliente usando um módulo de rede do perfil.Then, it creates a client by using a network module from the profile. Por fim, ele cria uma rede virtual.Finally, it creates a virtual network.

    package main
    
    import (
       "context"
       "fmt"
       "github.com/Azure/azure-sdk-for-go/profiles/2019-03-01/network/mgmt/network"
       "github.com/Azure/go-autorest/autorest"
       "github.com/Azure/go-autorest/autorest/adal"
       "github.com/Azure/go-autorest/autorest/to"
    )
    
    var (
       activeDirectoryEndpoint = "yourLoginEndpointFromResourceManagerUrlMetadata"
       tenantID = "yourAzureStackTenantID"
       clientID = "yourServicePrincipalApplicationID"
       clientSecret = "yourServicePrincipalSecret"
       activeDirectoryResourceID = "yourAudienceFromResourceManagerUrlMetadata"
      subscriptionID = "yourSubscriptionID"
      baseURI = "yourResourceManagerURL"
      resourceGroupName = "existingResourceGroupName"
    )
    
    //CreateToken creates a service principal token
    func CreateToken() (adal.OAuthTokenProvider, error) {
       var token adal.OAuthTokenProvider
       oauthConfig, err := adal.NewOAuthConfig(activeDirectoryEndpoint, tenantID)
       token, err = adal.NewServicePrincipalToken(
           *oauthConfig,
           clientID,
           clientSecret,
           activeDirectoryResourceID)
       return token, err
    }
    
    func main() {
       token, _ := CreateToken()
       vnetClient := network.NewVirtualNetworksClientWithBaseURI(baseURI, subscriptionID)
       vnetClient.Authorizer = autorest.NewBearerAuthorizer(token)
       future, _ := vnetClient.CreateOrUpdate(
           context.Background(),
           resourceGroupName,
           "sampleVnetName",
           network.VirtualNetwork{
               Location: to.StringPtr("local"),
               VirtualNetworkPropertiesFormat: &network.VirtualNetworkPropertiesFormat{
                   AddressSpace: &network.AddressSpace{
                       AddressPrefixes: &[]string{"10.0.0.0/8"},
                   },
                   Subnets: &[]network.Subnet{
                       {
                           Name: to.StringPtr("subnetName"),
                           SubnetPropertiesFormat: &network.SubnetPropertiesFormat{
                               AddressPrefix: to.StringPtr("10.0.0.0/16"),
                           },
                       },
                   },
               },
           })
       err := future.WaitForCompletionRef(context.Background(), vnetClient.Client)
       if err != nil {
           fmt.Printf(err.Error())
           return
       }
    }
    

Alguns dos exemplos de código disponíveis para Azure Stack Hub usando o SDK go são:Some of the code samples available for Azure Stack Hub using the Go SDK are:

Próximas etapasNext steps