WordPress: Comment appeler l’API REST Azure Resource Manager à partir de C#

WordPress: Comment appeler l'API REST Azure Resource Manager à partir de C#

Mise à jour 17 janv. 2019: Si vous trouvez cette page à partir d’un moteur de recherche, gardez à l’esprit qu’elle a été écrite début 2016. Pensez à consulter un article plus à jour comme : Authentification avec les bibliothèques Azure pour .Net.

L’appel de l’API REST Azure Resource Manager à partir de C# est assez simple. Vous ajoutez simplement un jeton d’accès à l’en-tête de la demande. Cependant, obtenir ce jeton d’accès, surtout pour la première fois, implique quelques étapes.

Le but de cet article est de regrouper toutes les étapes au même endroit afin de montrer comment écrire un programme C# qui effectue des appels REST pour afficher et créer des ressources d’infrastructure Azure de base.

Remarque : Deux modèles de déploiement sont actuellement disponibles dans Azure. Les Services Cloud modèle, et le plus récent Gestionnaire de ressources Azure modèle, également appelé ARM. Rendez-vous ici pour en savoir plus sur les différences entre les deux modèles : Comprendre le déploiement de Resource Manager et le déploiement classique. Cet article concerne la programmation sur le modèle ARM dans REST. Une bibliothèque gérée est également disponible pour Azure Resource Manager. Je choisis REST ici pour pouvoir passer des appels qui ne sont pas encore dans la bibliothèque gérée, et également utiliser les mêmes appels à partir d’autres langages de programmation.

Étapes de haut niveau

Divisons le processus de développement d’applications REST de bout en bout en 7 étapes simples :

Les quatre premières étapes sont des étapes de configuration d’application uniques : création et enregistrement d’une application auprès d’Azure, octroi d’autorisations et obtention des détails dont vous avez besoin. Il y a une excellente description de ces étapes ici : Authentification d’un principal de service avec Azure Resource Manager.

1. Créez un nouveau Application Azure Active Directory. Cela crée une définition de votre application et l’enregistre auprès d’Azure.

2. Créez un Chef de service. Il s’agit d’un « utilisateur » Active Directory qui représente une application automatisée. Pour une explication plus détaillée de ce que sont les objets Application et Service Principal, consultez : Objets Application et Objets Principal de service.

3. Accordez les autorisations au principal du service (par exemple, Contributeur) sur votre abonnement. Ne créez pas de « Reader » ou vous ne pourrez pas faire grand-chose, à moins que ce ne soit votre intention.

4. Créez un objet d’identification pour votre application, et utilisez-le pour obtenir le Identifiant du locataire pour le contexte d’authentification. Pour plus d’informations, consultez Qu’est-ce qu’un locataire Azure AD ?

Les étapes 5 à 7 couvrent la configuration de Visual Studio et l’authentification de base de votre code d’application. L’une de ces étapes : l’étape 6 – obtenir un jeton d’accès, est également partiellement couverte par l’authentification susmentionnée d’un principal de service.

5. Installez le package d’authentification Active Directory dans Visual Studio.

6. Obtenez un jeton d’accès pour l’application dans votre programme C#.

7. Utilisez le jeton pour autoriser un appel REST.

Étapes détaillées

Si vous avez déjà effectué ou connaissez l’une de ces étapes, passez à celles qui vous intéressent.

Conditions préalables

Les étapes de configuration de l’application uniques détaillées ici utilisent Outils de ligne de commande Azure. Vous aurez besoin de la dernière version d’Azure PowerShell ou de la CLI. Dans ce cas, j’ai utilisé Azure PowerShell 1.0+, mais les instructions PowerShell et CLI peuvent être trouvées dans le lien Authentifier un principal de service avec Azure Resource Manager. La meilleure façon d’installer Azure PowerShell (si vous me le demandez, ce que vous n’avez pas fait) consiste à installer le module Azure à partir de la galerie PowerShell.

Les commandes PowerShell de base pour installer Azure PowerShell et vous connecter à votre compte sont :

Set-ExecutionPolicy RemoteSigned
Module d’installation AzureRM
Installer-AzureRM
Connexion-AzureRmAccount

Noter: les commandes seraient différentes si vous utilisez une ancienne version (pré-1.0) d’Azure PowerShell.

Vous aurez également besoin de Visual Studio. J’ai testé avec 2015 Professional.

1. Créer une nouvelle application Azure Active Directory

Assurez-vous d’avoir sélectionné l’abonnement Azure que vous souhaitez utiliser (si vous en avez plusieurs) :

select-azurermsubscription –SubscriptionName

Lorsque vous enregistrez une application, donnez-lui un nom d’affichage, une page d’accueil (qui n’a pas besoin d’exister) et un mot de passe, par ex.

$azureAdApplication = New-AzureRmADApplication -DisplayName « mon application ARM » -HomePage « https://msftstack..com/ » -IdentifierUris « https://msftstack..com/ » -Mot de passe « xxxxxxx »

Notez $azureAdApplication.ApplicationId – votre application C# l’utilisera.

2. Créer un principal de service

La création d’une application génère un ID d’application, que vous utilisez ensuite pour créer le principal du service :

Nouveau-AzureRmADServicePrincipal -ApplicationId $azureAdApplication.ApplicationId

3. Accordez les autorisations au principal du service

Accordez maintenant les autorisations dont disposera votre instance d’application. Par exemple, si vous attribuez un rôle de « Lecteur », votre application ne pourra pas supprimer ou créer des ressources Azure. Vous pouvez trouver une liste de définitions de rôles parmi lesquelles choisir ici : RBAC : Rôles intégrés.

Cet exemple attribue des autorisations de lecture-écriture de base à l’aide de la Donateur rôle:

New-AzureRmRoleAssignment -RoleDefinitionName Contributor -ServicePrincipalName $azureAdApplication.ApplicationId

4. Créez un objet d’identification pour votre application

Obtenez l’abonnement dans lequel l’attribution de rôle a été créée. Il sera utilisé pour obtenir l’identifiant du locataire :

$subscription = Get-AzureRmSubscription –SubscriptionName

$creds = Obtenir les informations d’identification

Une invite apparaîtra. Ici, vous vous connectez au nom de l’application, donc lorsqu’elle vous demande le nom d’utilisateur, entrez le ID d’application, et utilisez le mot de passe que vous avez choisi lors de la création de l’application.

Obtenez maintenant le Identifiant du locataire pour le contexte d’authentification :

Login-AzureRmAccount -Credential $creds -ServicePrincipal -Tenant $subscription.TenantId

Vous obtiendrez une liste comme celle-ci :

Environnement : AzureCloud
Compte :
Identifiant du locataire :
Identifiant d’abonnement :

Les Identifiant de compte (AKA ApplicationId) et Identifiant du locataire, ainsi que votre mot de passe d’application, sont les valeurs que votre programme devra authentifier.

5. Installez le package d’authentification Active Directory dans Visual Studio

L’application C# créera un AuthenticationContext. Pour que ces appels soient résolus, vous devez installer le package Nuget Microsoft.IdentityModel.Clients.ActiveDirectory dans Visual Studio (référence : http://www.cloudidentity.com/blog/2013/09/12/active-directory-authentication-library -adal-v1-for-net-general-availability/).

Le package est disponible dans la galerie NuGet ici : https://www.nuget.org/packages/Microsoft.IdentityModel.Clients.ActiveDirectory/1.0.0

6. Obtenez un jeton d’accès pour l’application dans votre programme C#

Dans votre code C#, ajoutez une référence d’assembly pour le modèle d’identité ActiveDirectory :

en utilisant Microsoft.IdentityModel.Clients.ActiveDirectory ;

Et ajoutez une méthode pour obtenir un jeton d’accès à l’aide de votre tenantId, applicationId et mot de passe d’application :

public string GetAccessToken()
{
    string authContextURL = "https://login.windows.net/" + tenantId;
    var authenticationContext = new AuthenticationContext(authContextURL);
    var credential = new ClientCredential(clientId: , clientSecret: );
    var result = authenticationContext.AcquireToken(resource: "https://management.azure.com/", clientCredential: credential);

    if (result == null)
    {
        throw new InvalidOperationException("Failed to obtain the JWT token");
    }

    string token = result.AccessToken;
    return token;
}

Ne codez pas en dur ces valeurs dans un programme réel. Pour mon application de démonstration, j’ajoute un onglet de configuration où je peux enregistrer des valeurs spécifiques à l’abonnement en tant que métadonnées d’application.

7. Utilisez le jeton pour autoriser un appel REST

Désormais, tout est configuré pour effectuer des appels REST définis dans l’API REST Azure Resource Manager.

Par exemple pour faire un AVOIR avec un appel pour répertorier les groupes de ressources dans un abonnement, votre URI ressemblerait à ceci : https://management.azure.com/subscriptions//resourceGroups?api-version=2015-01-01 :

Voici une méthode générique pour effectuer un appel GET et renvoyer la sortie sous forme de chaîne. Notez comment le jeton d’authentification est ajouté en tant qu’en-tête :

private string doGET(string URI, String token)
{
    Uri uri = new Uri(String.Format(URI));

    // Create the request
    var httpWebRequest = (HttpWebRequest)WebRequest.Create(uri);
    httpWebRequest.Headers.Add(HttpRequestHeader.Authorization, "Bearer " + token);
    httpWebRequest.ContentType = "application/json";
    httpWebRequest.Method = "GET";

    // Get the response
    HttpWebResponse httpResponse = null;
    try
    {
        httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
    }
    catch (Exception ex)
    {
        MessageBox.Show("Error from : " + uri + ": " + ex.Message,
                        "HttpWebResponse exception", MessageBoxButton.OK, MessageBoxImage.Error);
        return null;
    }

    string result = null;
    using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
    {
        result = streamReader.ReadToEnd();
    }

    return result;
}

ou pour faire un METTRE:

private string doPUT(string URI, string body, String token)
{
    Uri uri = new Uri(String.Format(URI));

    // Create the request
    var httpWebRequest = (HttpWebRequest)WebRequest.Create(uri);
    httpWebRequest.Headers.Add(HttpRequestHeader.Authorization, "Bearer " + token);
    httpWebRequest.ContentType = "application/json";
    httpWebRequest.Method = "PUT";

    try
    {
        using (var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
        {
            streamWriter.Write(body);
            streamWriter.Flush();
            streamWriter.Close();
        }
    }
    catch (Exception ex)
    {
        MessageBox.Show("Error setting up stream writer: " + ex.Message,
            "GetRequestStream exception", MessageBoxButton.OK, MessageBoxImage.Error);
    }

    // Get the response
    HttpWebResponse httpResponse = null;
    try
    {
        httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
    }
    catch (Exception ex)
    {
        MessageBox.Show("Error from : " + uri + ": " + ex.Message,
                        "HttpWebResponse exception", MessageBoxButton.OK, MessageBoxImage.Error);
        return null;
    }

    string result = null;
    using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
    {
        result = streamReader.ReadToEnd();
    }
    return result;
}


Mettre tous ensemble

Pour rassembler ces concepts, voici une application de démonstration qui effectue des appels ARM de base. Dans cet exemple, un jeton d’authentification est demandé à chaque fois que vous appuyez sur le bouton GET/PUT/DELETE, car le jeton a un délai d’expiration. Il existe également des boutons arbitraires pour créer un URI et ajouter la version de l’API. Arbitraire parce que je travaille actuellement sur Azure Virtual Machine Scale Sets, j’ai donc ajouté un bouton pour les répertorier, et j’ajouterai probablement d’autres boutons de raccourci si nécessaire : https://github.com/gbowerman/armapp/

armapp

Que faire ensuite

La prochaine étape consisterait à utiliser la désérialisation JSON pour traiter la sortie JSON des appels REST.

Un autre domaine que je prévois d’étudier est l’obtention d’un jeton d’authentification pour d’autres langages comme Python.

All the CMS Templates You Could Ask For.

WordPress: Comment appeler l'API REST Azure Resource Manager à partir de C#

2M+ items from the worlds largest marketplace for CMS TemplatesEnvato Market.



WordPress: Comment appeler l'API REST Azure Resource Manager à partir de C#

#Comment #appeler #lAPI #REST #Azure #Resource #Manager #partir