Snelstartgids: een virtuele Azure-machine implementeren vanuit een sjabloon met de Azure SDK voor Go

In deze snelstartgids leert u hoe u resources implementeert vanuit een Azure Resource Manager-sjabloon met behulp van de Azure SDK voor Go. Sjablonen zijn momentopnames van alle resources binnen een Azure-resourcegroep. Gaandeweg raakt u bekend met de functionaliteiten en conventies van de SDK.

Aan het einde van deze snelstartgids voert u een VM uit waarbij u zich aanmeldt met een gebruikersnaam en een wachtwoord.

Als u nog geen abonnement op Azure hebt, maakt u een gratis account aan.

Azure Cloud Shell starten

De Azure Cloud Shell is een interactieve shell die wordt uitgevoerd op Azure. In deze shell zijn algemene hulpprogramma's vooraf geïnstalleerd en geconfigureerd voor gebruik met uw account. Selecteer Kopiëren om de code te kopiëren, plak deze in Cloud Shell en druk vervolgens op Enter om de code uit te voeren.

U kunt Cloud Shell op verschillende manieren starten:

Als u een lokale installatie van Azure CLI gebruikt, vereist deze snelstart CLI-versie 2.0.28 of hoger. Voer az --version uit om te controleren of de installatie van uw CLI voldoet aan deze vereiste. Als u uw CLI wilt installeren of upgraden, raadpleegt u De Azure CLI installeren.

De Azure SDK voor Go installeren

De Azure SDK voor Go is compatibel met Go-versie 1.8 en hoger. Voor omgevingen die gebruikmaken van Azure Stack-profielen is Go-versie 1.9 de minimale vereiste. Volg de installatie-instructies voor Go als u Go moet installeren.

U downloadt de Azure SDK voor Go en de afhankelijkheden ervan via go get.

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

Een service-principal maken

Als u zich niet-interactief met een toepassing wilt aanmelden bij Azure, hebt u een service-principal nodig. Service-principals zijn onderdeel van op rollen gebaseerd toegangsbeheer (RBAC), waarmee een unieke gebruikersidentiteit wordt gemaakt. Als u een nieuwe service-principal wilt maken met de CLI, voert u de volgende opdracht uit:

az ad sp create-for-rbac --role Contributor --sdk-auth > quickstart.auth

Stel de omgevingsvariabele AZURE_AUTH_LOCATION in op het volledige pad naar dit bestand. De SDK zoekt en leest vervolgens de referenties rechtstreeks uit dit bestand. U hoeft geen wijzigingen door te voeren of gegevens vast te leggen vanuit de service-principal.

Code ophalen

Haal de snelstartcode en alle afhankelijkheden ervan op met go get.

go get -u -d github.com/Azure-Samples/azure-sdk-for-go-samples/quickstarts/deploy-vm/...

U hoeft geen wijzigingen in de broncode door te voeren als de variabele AZURE_AUTH_LOCATION correct is ingesteld. Wanneer het programma wordt uitgevoerd, worden de benodigde verificatiegegevens van daaruit geladen.

De code uitvoeren

Voer de snelstart uit met de opdracht go run.

cd $GOPATH/src/github.com/Azure-Samples/azure-sdk-for-go-samples/quickstarts/deploy-vm
go run main.go

Als de implementatie succesvol is, krijgt u een bericht met de gebruikersnaam, het IP-adres en het wachtwoord voor aanmelding bij de nieuw gemaakte virtuele machine. Gebruik SSH om u aan te melden bij deze machine om te bekijken of deze actief is.

Opschonen

Schoon de resources die tijdens deze snelstart zijn gemaakt op door de resourcegroep met de CLI te verwijderen.

az group delete -n GoVMQuickstart

Verwijder ook de service-principal die is gemaakt. In het bestand quickstart.auth staat een JSON-sleutel voor clientId. Kopieer deze waarde in de omgevingsvariabele CLIENT_ID_VALUE en voer de volgende Azure CLI-opdracht uit:

az ad sp delete --id ${CLIENT_ID_VALUE}

Waar u de waarde voor CLIENT_ID_VALUE invoert vanuit quickstart.auth.

De code uitgesplitst

Wat de snelstartcode doet, wordt uitgesplitst in een blok variabelen en verschillende kleine functies die hier allemaal worden behandeld.

Variabelen, constanten en typen

Aangezien dit een zelfstandige snelstart is, maakt deze gebruik van globale constanten en variabelen.

const (
    resourceGroupName     = "GoVMQuickstart"
    resourceGroupLocation = "eastus"

    deploymentName = "VMDeployQuickstart"
    templateFile   = "vm-quickstart-template.json"
    parametersFile = "vm-quickstart-params.json"
)

// Information loaded from the authorization file to identify the client
type clientInfo struct {
    SubscriptionID string
    VMPassword     string
}

var (
    ctx        = context.Background()
    clientData clientInfo
    authorizer autorest.Authorizer
)

Er worden waarden opgegeven waardoor de gemaakte resources hun naam krijgen. De locatie wordt hier ook opgegeven. Deze kunt u aanpassen om te zien hoe implementaties zich in andere datacenters gedragen. Niet elk datacenter beschikt over alle vereiste resources.

Het type clientInfo bewaart de informatie die vanuit het verificatiebestand is geladen om clients in te stellen in de SDK en om het VM-wachtwoord in te stellen.

De constanten templateFile en parametersFile verwijzen naar de bestanden die nodig zijn voor de implementatie. De authorizer wordt geconfigureerd door de Go-SDK voor verificatie en de variabele ctx is een authorizer voor de netwerkbewerkingen.

Verificatie en initialisatie

De init-functie stelt de verificatie in. Aangezien verificatie de hoofdvoorwaarde is voor alles in de snelstart, is het verstandig om dit als onderdeel van de initialisatie te gebruiken. Ook wordt er bepaalde informatie uit het verificatiebestand geladen die nodig is om clients en de virtuele machine te configureren.

func init() {
    var err error
    authorizer, err = auth.NewAuthorizerFromFile(azure.PublicCloud.ResourceManagerEndpoint)
    if err != nil {
        log.Fatalf("Failed to get OAuth config: %v", err)
    }

    authInfo, err := readJSON(os.Getenv("AZURE_AUTH_LOCATION"))
    clientData.SubscriptionID = (*authInfo)["subscriptionId"].(string)
    clientData.VMPassword = (*authInfo)["clientSecret"].(string)
}

Eerst wordt auth.NewAuthorizerFromFile aangeroepen om de verificatie-informatie te laden uit het bestand dat zich in bevindt. Vervolgens wordt dit bestand handmatig geladen door de functie readJSON (hier weggelaten) om de twee waarden op te halen die nodig zijn om de rest van het programma uit te voeren: de abonnements-id van de client en het geheim van de service-principal dat ook wordt gebruikt voor het wachtwoord van de virtuele machine.

Bewerkingsstroom in main()

De functie main is eenvoudig: deze geeft enkel de bewerkingsstroom aan en voert een foutencontrole uit.

func main() {
    group, err := createGroup()
    if err != nil {
        log.Fatalf("failed to create group: %v", err)
    }
    log.Printf("Created group: %v", *group.Name)

    log.Printf("Starting deployment: %s", deploymentName)
    result, err := createDeployment()
    if err != nil {
        log.Fatalf("Failed to deploy: %v", err)
    }
    if result.Name != nil {
        log.Printf("Completed deployment %v: %v", deploymentName, *result.Properties.ProvisioningState)
    } else {
        log.Printf("Completed deployment %v (no data returned to SDK)", deploymentName)
    }
    getLogin()
}

De stappen die door de code worden uitgevoerd, zijn in volgorde:

• De resourcegroep maken om te implementeren in (createGroup)
• De implementatie in deze groep maken (createDeployment)
• De aanmeldingsgegevens voor de geïmplementeerde VM ophalen en weergeven (getLogin)

De resourcegroep maken

De functie createGroup maakt de resourcegroep. Als u naar de aanroepstroom en argumenten kijkt, ziet u de manier waarop service-interacties binnen de SDK zijn gestructureerd.

func createGroup() (group resources.Group, err error) {
    groupsClient := resources.NewGroupsClient(clientData.SubscriptionID)
    groupsClient.Authorizer = authorizer

        return groupsClient.CreateOrUpdate(
                ctx,
                resourceGroupName,
                resources.Group{
                        Location: to.StringPtr(resourceGroupLocation)})
}

De algemene interactiestroom met een Azure-service is:

• Maak de client die gebruikmaakt van de methode service.New*Client(), waarbij * het resourcetype is van de service waarmee u wilt communiceren. Deze functie haalt altijd een abonnements-id op.
• Stel de autorisatiemethode voor de client in, waardoor deze kan communiceren met de externe API.
• Laat de methode de client aanroepen die overeenkomt met de externe API. De methoden van serviceclients gebruiken doorgaans de naam van de resource en een metagegevensobject.

De functie to.StringPtr wordt gebruikt om een typeconversie uit te voeren. De parameters voor methoden van de SDK gebruiken bijna exclusief aanwijzers, dus worden er methoden voor gebruiksgemak gebruikt om de typeconversie eenvoudig te maken. Raadpleeg de documentatie voor de module autorest/to voor de volledige lijst met eenvoudige conversieprogramma's en hun gedrag.

De methode groupsClient.CreateOrUpdate retourneert een aanwijzer naar een gegevenstype die de gehele resourcegroep vertegenwoordigt. Een rechtstreeks geretourneerde waarde van dit type geeft een korte bewerking aan die synchroon moet zijn. In de volgende sectie ziet u een voorbeeld van een langdurige bewerking en ziet u hoe u daarmee communiceert.

De implementatie uitvoeren

Nadat de resourcegroep is gemaakt, is het tijd om de implementatie uit te voeren. Deze code wordt opgedeeld in kleinere secties om nadruk te leggen op verschillende onderdelen van de logica ervan.

func createDeployment() (deployment resources.DeploymentExtended, err error) {
    template, err := readJSON(templateFile)
    if err != nil {
        return
    }
    params, err := readJSON(parametersFile)
    if err != nil {
        return
    }
    (*params)["vm_password"] = map[string]string{
        "value": clientData.VMPassword,
    }
        // ...

De implementatiebestanden worden geladen door readJSON, waarvan de details in deze zelfstudie worden overgeslagen. Deze functie retourneert een *map[string]interface{}, het type dat wordt gebruikt om de metagegevens van de aanroep van de resource-implementatie te bouwen. Het wachtwoord van de virtuele machine wordt ook handmatig ingesteld op de implementatieparameters.

        // ...

    deploymentsClient := resources.NewDeploymentsClient(clientData.SubscriptionID)
    deploymentsClient.Authorizer = authorizer

    deploymentFuture, err := deploymentsClient.CreateOrUpdate(
        ctx,
        resourceGroupName,
        deploymentName,
        resources.Deployment{
            Properties: &resources.DeploymentProperties{
                Template:   template,
                Parameters: params,
                Mode:       resources.Incremental,
            },
        },
    )
    if err != nil {
        return
    }

Deze code volgt hetzelfde patroon als het maken van de resourcegroep. Er wordt een nieuwe client gemaakt die kan verifiëren met Azure, waarna een methode wordt aangeroepen. De methode heeft zelfs dezelfde naam (CreateOrUpdate) als de bijbehorende methode voor resourcegroepen. Dit patroon is zichtbaar in de gehele SDK. Methoden die gelijksoortig werk uitvoeren, hebben doorgaans dezelfde naam.

Het grootste verschil zit in de geretourneerde waarde van de methode deploymentsClient.CreateOrUpdate. Deze waarde is een type vertraging, dat het vertragingsontwerppatroon volgt. Vertragingen vertegenwoordigen een langdurige bewerking in Azure die u kunt controleren, annuleren of blokkeren bij de voltooiing.

        //...
    err = deploymentFuture.Future.WaitForCompletion(ctx, deploymentsClient.BaseClient.Client)
    if err != nil {
        return
    }
    return deploymentFuture.Result(deploymentsClient)
}

Voor dit voorbeeld is het beste om te wachten tot de bewerking is voltooid. Voor het wachten op een vertraging is zowel een contextobject nodig als de client die de heeft gemaakt. Er zijn hier twee mogelijke foutbronnen: een fout die wordt veroorzaakt aan de clientzijde wanneer de methode wordt aangeroepen en een foutmelding vanaf de server. De laatste wordt geretourneerd als onderdeel van de aanroep deploymentFuture.Result.

Het toegewezen IP-adres ophalen

Als u iets wilt doen met de nieuw gemaakte VM, hebt u het toegewezen IP-adres nodig. IP-adressen zijn afzonderlijke Azure-resources en gebonden aan Network Interface Controller-resources (NIC).

func getLogin() {
    params, err := readJSON(parametersFile)
    if err != nil {
        log.Fatalf("Unable to read parameters. Get login information with `az network public-ip list -g %s", resourceGroupName)
    }

    addressClient := network.NewPublicIPAddressesClient(clientData.SubscriptionID)
    addressClient.Authorizer = authorizer
    ipName := (*params)["publicIPAddresses_QuickstartVM_ip_name"].(map[string]interface{})
    ipAddress, err := addressClient.Get(ctx, resourceGroupName, ipName["value"].(string), "")
    if err != nil {
        log.Fatalf("Unable to get IP information. Try using `az network public-ip list -g %s", resourceGroupName)
    }

    vmUser := (*params)["vm_user"].(map[string]interface{})

    log.Printf("Log in with ssh: %s@%s, password: %s",
        vmUser["value"].(string),
        *ipAddress.PublicIPAddressPropertiesFormat.IPAddress,
        clientData.VMPassword)
}

Deze methode is gebaseerd op informatie die in het parameterbestand wordt opgeslagen. De code kan rechtstreeks een query uitvoeren op de VM om de NIC op te halen, de query uitvoeren op de NIC om de IP-resource op te halen en vervolgens rechtstreeks een query uitvoeren op de IP-resource. Dat is een lange reeks aan afhankelijkheden en op te lossen bewerkingen, waardoor de uitvoering ervan duur wordt. Aangezien de JSON-informatie lokaal is, kan deze worden geladen.

De waarde voor de gebruiker van de virtuele machine wordt ook geladen vanuit de JSON. Het wachtwoord van de virtuele machine is eerder geladen vanuit het verificatiebestand.

Volgende stappen

In deze snelstartgids hebt u een bestaande sjabloon gebruikt en deze via Go geïmplementeerd. U hebt vervolgens via SSH verbinding gemaakt met de nieuw gemaakte VM.

Als u meer te weten wilt komen over werken met virtuele machines in de Azure-omgeving met Go, kunt u de Azure-berekeningsvoorbeelden voor Go of de voorbeelden van Azure-resourcebeheer voor Go bekijken.

Zie Verificatie met de Azure SDK voor Go voor meer informatie over de beschikbare verificatiemethoden in de SDK en welke verificatietypen ze ondersteunen.