Use perfis de versão API com Go in Azure Stack HubUse API version profiles with Go in Azure Stack Hub

Ir e ver os perfisGo and version profiles

Um perfil é uma combinação de diferentes tipos de recursos com diferentes versões de diferentes serviços.A profile is a combination of different resource types with different versions from different services. A utilização de um perfil ajuda-o a misturar e a combinar 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 a sua aplicação bloqueando versões API específicas.Stability for your app by locking to specific API versions.
  • Compatibilidade para a sua aplicação com o Azure Stack Hub e os centros de dados regionais Azure.Compatibility for your app with Azure Stack Hub and regional Azure datacenters.

No Go SDK, os perfis estão disponíveis no caminho dos perfis.In the Go SDK, profiles are available under the profiles path. Os números da versão de perfil estão rotulados no formato YYYY-MM-DD.Profile version numbers are labeled in the YYYY-MM-DD format. A mais recente versão de perfil Azure Stack Hub API é 2019-03-01 para as versões Azure Stack Hub 1904 ou mais tarde.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 a partir 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 Compute a partir do perfil 2019-03-01, utilize 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 Azure SDK para GoInstall the Azure SDK for Go

  1. Instale Git.Install Git. Para obter instruções, consulte "Começar " - Instalar git.For instructions, see Getting Started - Installing Git.

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

  3. Instale o Azure Go SDK e as suas dependências executando o seguinte comando de 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 Go SDKThe Go SDK

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

Go-AutoRest dependênciasGo-AutoRest dependencies

O Go SDK depende dos módulos Azure Go-AutoRest para enviar pedidos DE REST para os pontos finais do Azure Resource Manager.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 de Azure Go-AutoRest no GitHub.You must import the Azure Go-AutoRest module dependencies from Azure Go-AutoRest on GitHub. Pode encontrar os comandos de festa de instalação na secção Instalar.You can find the install bash commands in the Install section.

Como usar perfis Go SDK no Azure Stack HubHow to use Go SDK profiles on Azure Stack Hub

Para executar uma amostra do código Go no Azure Stack Hub, siga estes passos:To run a sample of Go code on Azure Stack Hub, follow these steps:

  1. Instale o Azure SDK para Go e as suas dependências.Install the Azure SDK for Go and its dependencies. Para obter instruções, consulte a secção anterior, instale Azure SDK para ir.For instructions, see the previous section, Install Azure SDK for Go.

  2. Obtenha a informação de metadados no ponto final do Gestor de Recursos.Get the metadata info from the Resource Manager endpoint. O ponto final devolve um ficheiro JSON com a informação necessária para executar o seu código Go.The endpoint returns a JSON file with the info required to run your Go code.

    Nota

    O ResourceManagerUrl no Kit de Desenvolvimento da Pilha de Azure (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

    Ficheiro JSON da amostra: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 subscrição e guarde o ID de subscrição para ser usado mais tarde.If not available, create a subscription and save the subscription ID to be used later. Para obter informações sobre a criação de uma subscrição, consulte Criar subscrições para ofertas no Azure Stack Hub.For info on creating a subscription, see Create subscriptions to offers in Azure Stack Hub.

  4. Crie um principal de serviço que utilize um segredo de cliente, com âmbito de subscrição e função de Proprietário.Create a service principal that uses a client secret, with Subscription scope and Owner role. Guarde a identificação principal do serviço e o segredo.Save the service principal ID and secret. Para obter informações sobre a criação de um principal serviço para o Azure Stack Hub, consulte utilizar uma identidade de aplicação para aceder aos recursos.For information about creating a service principal for Azure Stack Hub, see Use an app identity to access resources. O seu ambiente Azure Stack Hub está agora montado.Your Azure Stack Hub environment is now set up.

  5. Importe um módulo de serviço do perfil Go SDK no seu código.Import a service module from the Go SDK profile in your code. A versão atual do perfil Azure Stack Hub é 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, utilize 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. Na sua função, crie e autença um cliente com uma chamada de função nova cliente.In your function, create and authenticate a client with a New client function call. Para criar um cliente de rede virtual, utilize 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)
    

    <baseURI>Desaprotendo o valor ResourceManagerUrl utilizado no passo 2.Set <baseURI> to the ResourceManagerUrl value used in step 2. <subscriptionID>Desaprova o valor subscriçãoID guardado do passo 3.Set <subscriptionID> to the SubscriptionID value saved from step 3.

    Para criar o símbolo, consulte a próxima secção.To create the token, see the next section.

  7. Invoque os métodos da API utilizando o cliente que criou no passo anterior.Invoke API methods by using the client that you created in the previous step. Por exemplo, para criar uma rede virtual utilizando o cliente a partir do passo anterior, consulte o seguinte exemplo: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 um exemplo completo de criação de uma rede virtual no Azure Stack Hub utilizando o perfil Go SDK, veja 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 Authorizer do Azure Ative Directory utilizando o Go SDK, instale os módulos Go-AutoRest.To get the Authorizer property from Azure Active Directory using the Go SDK, install the Go-AutoRest modules. Estes módulos já deveriam ter sido instalados com a instalação "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 Autor deve ser definido como o autor do cliente de recurso.The Authorizer must be set as the authorizer for the resource client. Existem diferentes formas de obter fichas autorizadas no Azure Stack Hub usando credenciais de cliente:There are different ways to get authorizer tokens on Azure Stack Hub by using client credentials:

  1. Se estiver disponível um titular de serviço com papel de proprietário na subscrição, ignore este passo.If a service principal with owner role on the subscription is available, skip this step. Caso contrário, consulte utilizar uma identidade de aplicação para aceder a recursos para obter instruções sobre a criação de um principal de serviço que utilize um segredo de cliente, e para ajudar a atribuir-lhe uma função de "proprietário" aparada à sua subscrição.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 o iD principal da aplicação de serviço e o segredo.Be sure to capture the service principal application ID and secret.

  2. Importe o pacote adal da Go-AutoRest no 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 utilizando o método NewOAuthConfig a partir de 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)
    }
    

    Definir <activeDirectoryEndpoint> o valor da propriedade a partir dos loginEndpoint ResourceManagerUrl metadados recuperados na secçã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. Desaça o <tenantID> valor para o seu ID de inquilino Azure Stack Hub.Set the <tenantID> value to your Azure Stack Hub tenant ID.

  4. Finalmente, crie um token principal de serviço utilizando o NewServicePrincipalToken método a partir 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
    

    Definido <activeDirectoryResourceID> como um dos valores na lista de "público" dos metadados ResourceManagerUrl recuperados na secçã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. Definir <clientID> para o ID principal de aplicação de serviço guardado quando o principal serviço foi criado na secçã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. Definir <clientSecret> para o segredo de aplicação principal do serviço guardado quando o diretor de serviço foi criado na secçã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 uma amostra do código Go que cria uma rede virtual no Azure Stack Hub.This example shows a sample of Go code that creates a virtual network on Azure Stack Hub. Para obter exemplos completos do Go SDK, consulte o repositório de amostras Azure Go SDK.For complete examples of the Go SDK, see the Azure Go SDK samples repository. As amostras do Azure Stack Hub estão disponíveis sob o 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.

Nota

Para executar o código neste exemplo, verifique se a subscrição utilizada tem o fornecedor de recursos da Rede listado como Registado.To run the code in this example, verify that the subscription used has the Network resource provider listed as Registered. Para verificar, procure a subscrição no portal Azure Stack Hub e selecione fornecedores de recursos.To verify, look for the subscription in the Azure Stack Hub portal, and select Resource providers.

  1. Importe as embalagens necessárias no seu código.Import the required packages in your code. Utilize o perfil mais recente disponível no Azure Stack Hub 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 as variáveis ambientais.Define your environment variables. Para criar uma rede virtual, é necessário 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 definiu as variáveis ambientais, adicione um método para criar um token de autenticação utilizando 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 a autenticação, consulte a secçã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 main método.Add the main method. O main método primeiro recebe um símbolo usando o método que é definido no passo anterior.The main method first gets a token by using the method that is defined in the previous step. Em seguida, cria um cliente usando um módulo de rede a partir do perfil.Then, it creates a client by using a network module from the profile. Finalmente, 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
       }
    }
    

Algumas das amostras de código disponíveis para O Azure Stack Hub utilizando o Go SDK são:Some of the code samples available for Azure Stack Hub using the Go SDK are:

Passos seguintesNext steps