Usare i profili di versione dell'API con Go nell'hub Azure StackUse API version profiles with Go in Azure Stack Hub

Profili go e VersionGo and version profiles

Un profilo è una combinazione di tipi di risorse differenti con versioni diverse di servizi diversi.A profile is a combination of different resource types with different versions from different services. L'uso di un profilo consente di combinare e associare tipi di risorse diversi.Using a profile helps you mix and match between different resource types. I profili possono offrire i seguenti vantaggi:Profiles can provide the following benefits:

  • Stabilità per l'app mediante il blocco di versioni API specifiche.Stability for your app by locking to specific API versions.
  • Compatibilità per l'app con hub Azure Stack e Data Center di Azure locali.Compatibility for your app with Azure Stack Hub and regional Azure datacenters.

In go SDK i profili sono disponibili nel percorso profili.In the Go SDK, profiles are available under the profiles path. I numeri di versione del profilo sono contrassegnati nel formato aaaa-mm-gg .Profile version numbers are labeled in the YYYY-MM-DD format. La versione più recente del profilo API dell'hub Azure Stack è 2019-03-01 per le versioni di hub Azure stack 1904 o versione successiva.The latest Azure Stack Hub API profile version is 2019-03-01 for Azure Stack Hub versions 1904 or later. Per importare un servizio specificato da un profilo, importare il modulo corrispondente dal profilo.To import a given service from a profile, import its corresponding module from the profile. Ad esempio, per importare il servizio di calcolo dal profilo 2019-03-01 , usare il codice seguente: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"

Installare Azure SDK per GoInstall the Azure SDK for Go

  1. Installare Git.Install Git. Per istruzioni, vedere Introduzione-installazione di git.For instructions, see Getting Started - Installing Git.

  2. Installare il linguaggio di programmazione Go.Install the Go programming language. I profili API per Azure richiedono la versione 1,9 o successiva.API profiles for Azure require Go version 1.9 or newer.

  3. Installare Azure go SDK e le relative dipendenze eseguendo il comando bash seguente: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/...
    

SDK goThe Go SDK

Per altre informazioni su Azure go SDK, vedere i collegamenti seguenti:You can find more information about the Azure Go SDK at the following links:

Dipendenze Go-AutoRestGo-AutoRest dependencies

Go SDK dipende dai moduli Azure go-autorest per inviare richieste REST agli endpoint Azure Resource Manager.The Go SDK depends on the Azure Go-AutoRest modules to send REST requests to Azure Resource Manager endpoints. È necessario importare le dipendenze del modulo Azure go-autorest da Azure Go-AutoRest su GitHub.You must import the Azure Go-AutoRest module dependencies from Azure Go-AutoRest on GitHub. I comandi install bash sono disponibili nella sezione Install (installa ).You can find the install bash commands in the Install section.

Come usare i profili go SDK nell'hub Azure StackHow to use Go SDK profiles on Azure Stack Hub

Per eseguire un esempio di codice go nell'hub Azure Stack, seguire questa procedura:To run a sample of Go code on Azure Stack Hub, follow these steps:

  1. Installare il Azure SDK per Go e le relative dipendenze.Install the Azure SDK for Go and its dependencies. Per istruzioni, vedere la sezione precedente, Install Azure SDK per go.For instructions, see the previous section, Install Azure SDK for Go.

  2. Ottenere le informazioni sui metadati dall'endpoint Gestione risorse.Get the metadata info from the Resource Manager endpoint. L'endpoint restituisce un file JSON con le informazioni necessarie per eseguire il codice go.The endpoint returns a JSON file with the info required to run your Go code.

    Nota

    ResourceManagerUrl nella Azure stack Development Kit (Gabriele) è:https://management.local.azurestack.external/The ResourceManagerUrl in the Azure Stack Development Kit (ASDK) is: https://management.local.azurestack.external/
    Il ResourceManagerUrl nei sistemi integrati è: https://management.<region>.<fqdn>/The ResourceManagerUrl in integrated systems is: https://management.<region>.<fqdn>/
    Per recuperare i metadati necessari: <ResourceManagerUrl>/metadata/endpoints?api-version=1.0To retrieve the metadata required: <ResourceManagerUrl>/metadata/endpoints?api-version=1.0

    File JSON di esempio: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 non è disponibile, creare una sottoscrizione e salvare l'ID sottoscrizione da usare in un secondo momento.If not available, create a subscription and save the subscription ID to be used later. Per informazioni sulla creazione di una sottoscrizione, vedere creare sottoscrizioni per le offerte nell'Hub Azure stack.For info on creating a subscription, see Create subscriptions to offers in Azure Stack Hub.

  4. Creare un'entità servizio che utilizza un segreto client, con ambito sottoscrizione e ruolo proprietario .Create a service principal that uses a client secret, with Subscription scope and Owner role. Salvare l'ID e il segreto dell'entità servizio.Save the service principal ID and secret. Per informazioni sulla creazione di un'entità servizio per Azure Stack Hub, vedere usare un'identità dell'app per accedere alle risorse.For information about creating a service principal for Azure Stack Hub, see Use an app identity to access resources. L'ambiente di Azure Stack Hub è ora configurato.Your Azure Stack Hub environment is now set up.

  5. Importare un modulo del servizio dal profilo di go SDK nel codice.Import a service module from the Go SDK profile in your code. La versione corrente del profilo Hub Azure Stack è 2019-03-01.The current version of Azure Stack Hub profile is 2019-03-01. Per importare un modulo di rete dal tipo di profilo 2019-03-01 , ad esempio, usare il codice seguente: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. Nella funzione creare e autenticare un client con una nuova chiamata di funzione client.In your function, create and authenticate a client with a New client function call. Per creare un client di rete virtuale, usare il codice seguente: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)
    

    Impostare sul <baseURI> valore ResourceManagerUrl usato nel passaggio 2.Set <baseURI> to the ResourceManagerUrl value used in step 2. Impostare sul <subscriptionID> valore di SubscriptionId salvato al passaggio 3.Set <subscriptionID> to the SubscriptionID value saved from step 3.

    Per creare il token, vedere la sezione successiva.To create the token, see the next section.

  7. Richiamare i metodi API utilizzando il client creato nel passaggio precedente.Invoke API methods by using the client that you created in the previous step. Ad esempio, per creare una rete virtuale usando il client del passaggio precedente, vedere l'esempio seguente: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( )
    

Per un esempio completo di creazione di una rete virtuale nell'hub Azure Stack usando il profilo go SDK, vedere l' esempio.For a complete example of creating a virtual network on Azure Stack Hub by using the Go SDK profile, see the example.

AutenticazioneAuthentication

Per ottenere la proprietà del provider di autorizzazioni da Azure Active Directory usando go SDK, installare i moduli go-autorest .To get the Authorizer property from Azure Active Directory using the Go SDK, install the Go-AutoRest modules. Questi moduli dovrebbero essere già installati con l'installazione di "go SDK".These modules should have been already installed with the "Go SDK" installation. In caso affermativo, installare il pacchetto di autenticazione da GitHub.If they aren't, install the authentication package from GitHub.

Il provider di autorizzazioni deve essere impostato come provider di autorizzazioni per il client di risorse.The Authorizer must be set as the authorizer for the resource client. Esistono diversi modi per ottenere i token di autorizzazione nell'hub Azure Stack usando le credenziali client:There are different ways to get authorizer tokens on Azure Stack Hub by using client credentials:

  1. Se è disponibile un'entità servizio con ruolo proprietario nella sottoscrizione, ignorare questo passaggio.If a service principal with owner role on the subscription is available, skip this step. In caso contrario, vedere usare un'identità dell'app per accedere alle risorse per istruzioni sulla creazione di un'entità servizio che usa un segreto client e per informazioni su come assegnare un ruolo "proprietario" con ambito alla sottoscrizione.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. Assicurarsi di acquisire l'ID applicazione e il segreto dell'entità servizio.Be sure to capture the service principal application ID and secret.

  2. Importare il pacchetto adal da go-autorest nel codice.Import the adal package from Go-AutoRest in your code.

    package main
    import "github.com/Azure/go-autorest/autorest/adal"
    
  3. Creare un oauthConfig usando il metodo NewOAuthConfig del modulo 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)
    }
    

    Impostare sul <activeDirectoryEndpoint> valore della loginEndpoint Proprietà dai ResourceManagerUrl metadati recuperati nella sezione precedente di questo documento.Set <activeDirectoryEndpoint> to the value of the loginEndpoint property from the ResourceManagerUrl metadata retrieved on the previous section of this document. Impostare il <tenantID> valore sull'ID tenant dell'Hub Azure stack.Set the <tenantID> value to your Azure Stack Hub tenant ID.

  4. Infine, creare un token dell'entità servizio usando il NewServicePrincipalToken metodo del modulo 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
    

    Impostare <activeDirectoryResourceID> su uno dei valori nell'elenco "audience" dei metadati ResourceManagerUrl recuperati nella sezione precedente di questo articolo.Set <activeDirectoryResourceID> to one of the values in the "audience" list from the ResourceManagerUrl metadata retrieved in the previous section of this article. Impostare <clientID> sull'ID applicazione dell'entità servizio salvato quando l'entità servizio è stata creata nella sezione precedente di questo articolo.Set <clientID> to the service principal application ID saved when the service principal was created in the previous section of this article. Impostare sul <clientSecret> segreto dell'applicazione dell'entità servizio salvato quando l'entità servizio è stata creata nella sezione precedente di questo articolo.Set <clientSecret> to the service principal application secret saved when the service principal was created in the previous section of this article.

EsempioExample

Questo esempio illustra un esempio di codice Go per la creazione di una rete virtuale nell'hub Azure Stack.This example shows a sample of Go code that creates a virtual network on Azure Stack Hub. Per esempi completi di go SDK, vedere il repository di esempi di Azure go SDK.For complete examples of the Go SDK, see the Azure Go SDK samples repository. Gli esempi di hub Azure Stack sono disponibili nel percorso ibrido all'interno delle cartelle dei servizi del repository.Azure Stack Hub samples are available under the hybrid path inside service folders of the repository.

Nota

Per eseguire il codice in questo esempio, verificare che la sottoscrizione utilizzata includa il provider di risorse di rete elencato come registrato.To run the code in this example, verify that the subscription used has the Network resource provider listed as Registered. Per verificare, cercare la sottoscrizione nel portale dell'hub Azure Stack e selezionare provider di risorse.To verify, look for the subscription in the Azure Stack Hub portal, and select Resource providers.

  1. Importare i pacchetti necessari nel codice.Import the required packages in your code. Usare il profilo disponibile più recente nell'hub Azure Stack per importare il modulo di rete: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. Definire le variabili di ambiente.Define your environment variables. Per creare una rete virtuale, è necessario disporre di un gruppo di risorse.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. Ora che sono state definite le variabili di ambiente, aggiungere un metodo per creare un token di autenticazione usando il pacchetto adal .Now that you've defined your environment variables, add a method to create an authentication token by using the adal package. Per ulteriori informazioni sull'autenticazione, vedere la sezione precedente.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. Aggiungere il metodo main.Add the main method. Il main metodo ottiene innanzitutto un token usando il metodo definito nel passaggio precedente.The main method first gets a token by using the method that is defined in the previous step. Crea quindi un client usando un modulo di rete dal profilo.Then, it creates a client by using a network module from the profile. Infine, crea una rete virtuale.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
       }
    }
    

Alcuni esempi di codice disponibili per Azure Stack Hub tramite Go SDK sono:Some of the code samples available for Azure Stack Hub using the Go SDK are:

Passaggi successiviNext steps