Exporter (0) Imprimer
Développer tout

Meilleures pratiques pour exécuter du code non managé dans des applications Azure

Mis à jour: juin 2014

Écrire du code.NET pour des applications Azure revient, pour une grande partie, à écrire du code .NET pour des applications Windows. Il existe toutefois de légères différences dont vous devez être conscient lorsque vous écrivez du code.NET pour l'une ou l'autre plateforme. Ce document fournit des recommandations pour l'exécution de code non managé/natif dans des applications Azure.

Auteurs Christian Martinez, Trace Young et Mark Simms

Les sections suivantes fournissent des recommandations que vous devez suivre pour vous assurer que le code natif s'exécute correctement lors du développement d'applications Azure qui appellent ce code natif.

Pour configurer le code natif à compiler en mode Version finale, cliquez avec le bouton droit sur le projet de code natif, sélectionnez Propriétés pour afficher la page Propriétés, puis choisissez l'option de configuration Version finale disponible sous l'onglet Générer de la page des propriétés :

noteRemarque
Des erreurs d'exécution avertissant qu'il manque des DLL, telles que msvcr100d.dll ou msvcp100d.dll, indiquent que le code natif que vous avez déployé a été compilé en mode Débogage. Les fichiers msvcr100d.dll et msvcp100d.dll ne sont pas des DLL redistribuables. Pour plus d'informations sur la définition des fichiers DLL C++ à redistribuer, consultez Détermination des DLL à redistribuer (http://go.microsoft.com/fwlink/p/?LinkId=236016).

Suivez ces étapes pour vérifier que votre application Azure peut localiser tout code natif référencé lors de son exécution dans l'émulateur de calcul Azure :

  1. Définissez les propriétés appropriées pour les fichiers compilés en code natif dans Visual Studio

    Incluez le fichier compilé en code natif en tant qu'élément de projet, puis dans la boîte de dialogue Propriétés du fichier, définissez l'option Copier dans le répertoire de sortie sur Toujours copier et l'option Action de génération sur Aucune.

    Cette opération copie le fichier compilé en code natif dans le répertoire \bin, ce qui permet à votre application Azure de localiser le fichier compilé en code natif lors de son exécution dans l'émulateur de calcul Azure.



  2. Lors du dépannage de l'implémentation de RoleEntry dans l'émulateur de calcul Azure, il peut être plus facile de résoudre les éventuels problèmes si vous copiez le fichier compilé en code natif dans le répertoire d'exécution devfabric

    • Par exemple, lorsque vous utilisez la version 1.5 du Kit de développement Azure SDK ou une version antérieure, copiez le fichier compilé en code natif dans le répertoire suivant :


      C:\Program Files\Azure SDK\[SDK Version]\bin\devfabric\x64\


    • Sinon, lorsque vous utilisez la version 1.6 du Kit de développement Azure SDK ou une version ultérieure, copiez le fichier compilé en code natif dans ce répertoire :


      C:\Program Files\Azure SDK\[SDK Version]\bin\runtimes\base\x64\

  3. Vérifier que les applications Azure s'exécutant dans une instance de rôle Web peuvent localiser n'importe quel code natif référencé

    Si une application Azure fait référence à du code natif qui est encapsulé avec C++/CLI et que l'application Azure s'exécute dans un instance de rôle Web, utilisez l'une des méthodes suivantes pour vous assurer que l'application Azure est en mesure de localiser le code natif référencé :



    noteRemarque
    Les étapes ci-dessous font référence au projet CppCliWebRole fourni avec l'exemple de code dans PinvokeCppCliInAzure.zip, téléchargeable à l'adresse http://azureunmanagedcode.codeplex.com/. Pour plus d'informations sur l'exemple de code, consultez Exemple de code : exécution de code natif à partir d'applications Azure.

    Méthode 1 : remplacer la variable d'environnement PATH, puis redémarrer IIS et l'émulateur de calcul Azure :

    1. Arrêtez et quittez l'émulateur de calcul Azure.

    2. Modifiez votre variable d'environnement PATH pour qu'elle désigne un répertoire contenant le code natif compilé.

    3. Tapez iisreset à partir d'une invite de commandes avec élévation de privilèges.

    4. Appuyez sur F5 pour exécuter le code d'exemple.

    Méthode 2 : utiliser une commande de démarrage

    Dans les étapes ci-dessous, le code natif se trouve dans le fichier ExampleNativeCode.dll.

    1. Arrêtez et quittez l'émulateur de calcul Azure.

    2. Ouvrez le fichier indist.cmd inclus avec le projet CppCliWebRole.

    3. Changez la ligne suivante :

      REM copy "%~dps0ExampleNativeCode.dll" "%windir%\system32\inetsrv"
      
      À :



      copy "%~dps0ExampleNativeCode.dll" "%windir%\system32\inetsrv"
      
    4. Enregistrez le projet.

    5. Appuyez sur F5 pour exécuter le code d'exemple.

    noteRemarque
    L'utilisation d'une commande de démarrage fonctionne également pour les déploiements réels. Si vous préférez éviter des références au répertoire système IIS, vous pouvez également créer et exécuter un script pour :

    1. Changer la variable d'environnement PATH pour qu'elle désigne le répertoire contenant le code natif compilé.

    2. Redémarrer IIS et tous les processus qui en dépendent.

Azure est une plateforme 64 bits, de même que les hôtes d'application Azure (rôle de travail et rôle Web). Si vous n'utilisez pas un environnement de développement 64 bits pur et que votre application référence du code natif, des erreurs seront générées. Un simple test pour vérifier que tout le code natif que vous référencez est de 64 bits consiste à le tester à l'aide d'applications de test de console qui sont codées en dur afin de s'exécuter comme des applications 64 bits.

Par défaut, seules les bibliothèques d'exécution Visual C++ pour Visual C++ 2008 sont installées sur les rôles Web et de travail Azure. Par conséquent, le code natif compilé dans la bibliothèque d'exécution Visual C++ pour d'autres versions de Visual C++ ne sera pas chargé dans les instances de rôle Web et de travail. Si Visual Studio 2008 et une version ultérieure sont installés sur le même ordinateur, utilisez la fonctionnalité de multiciblage native de Visual Studio pour créer des bibliothèques natives pour votre application avec l'ensemble d'outils de la plateforme Visual Studio 2008 (compilateur, éditeur de liens, en-têtes et bibliothèques). Pour en savoir plus sur l'utilisation de Visual Studio pour créer une application à l'aide de l'ensemble d'outils de la plateforme Visual Studio 2008, consultez Procédure : modifier l'ensemble d'outils du .Net Framework cible et de la plateforme(http://go.microsoft.com/fwlink/?LinkId=324964).

Ajoutez une tâche de démarrage élevée à votre projet de rôle Web pour copier et installer la version requise des bibliothèques d'exécution. Les étapes suivantes décrivent comment créer une tâche de démarrage élevée pour copier la version 64 bits du package redistribuable Microsoft Visual C++ 2010 dans un rôle Web/de travail et exécuter le package redistribuable pour installer les bibliothèques Visual C++ pour Visual C++ 2010 sur les instances de rôle Web/de travail. D'autres versions de Visual C++ nécessitent un package distribuable spécifique à cette version :

  1. Créez un dossier de démarrage pour votre projet de rôle Web ou de rôle de travail.

  2. Copiez vcredist_x64.exe (http://go.microsoft.com/fwlink/p/?LinkId=225987) dans le dossier de démarrage.

  3. Créez un fichier startup.cmd dans le dossier de démarrage.

  4. Modifiez startup.cmd, puis ajoutez la ligne suivante :


    "%~dps0vcredist_x64.exe" /q /norestart


  5. Modifiez les propriétés de vcredit_x64.exe et de startup.cmd à partir de l'Explorateur de solutions Visual Studio. Définissez l'option Action de génération sur Contenu et l'option Copier dans le répertoire de sortie sur Copier si plus récent.

  6. Modifiez le fichier ServiceDefinition.csdef pour le rôle en ajoutant la tâche de démarrage élevée suivante pour exécuter startup.cmd :


    < Task commandLine ="Startup\Startup.cmd" executionContext ="elevated" taskType ="simple" />

Le message d'erreur généré lorsqu'un assembly ne peut pas être chargé par l'émulateur de calcul Azure peut ne pas être intuitif. Pour résoudre les problèmes de chargement de fichiers dans une instance hôte de rôle Web ou de rôle de travail, utilisez Process Monitor comme suit :

  1. Téléchargez Process Monitor depuis la page Process Monitor v2.96 (http://go.microsoft.com/fwlink/p/?LinkID=137175).

  2. Lancez Process Monitor afin de résoudre les problèmes liés aux applications Azure chargeant des fichiers lors de leur exécution dans l'émulateur de calcul Azure.

  3. Définissez les paramètres de filtre comme mentionné ci-dessous pour l'hôte de l'émulateur de calcul Azure. Lors de la résolution des problèmes liés aux applications Azure s'exécutant dans un projet de rôle de travail, modifiez le filtre pour afficher des entrées avec le nom de processus WaWorkerHost.exe plutôt que WaWebHost.exe.







  4. Recherchez les messages de type NAME_NOT_FOUND. Cela vous aidera à isoler le fichier de bibliothèque manquant. Une fois que vous avez déterminé quel fichier est manquant, vous pouvez limiter la portée de la recherche en appliquant un filtre pour isoler uniquement les messages associés à ce fichier.

Pour permettre aux applications Azure d'exécuter le code natif 64 bits avec P/Invoke, commencez par configurer les rôles Web ou de travail associés avec le niveau de confiance totale .NET. Pour plus d'informations sur l'appel du code natif depuis des applications qui s'exécutent dans les rôles Web ou de travail Azure, consultez les ressources suivantes :

Cette section décrit l'exemple de code dans PinvokeCppCliInAzure.zip (http://go.microsoft.com/fwlink/p/?LinkId=236170), téléchargeable à l'adresse http://azureunmanagedcode.codeplex.com/

noteRemarque
Lorsque vous utilisez l'émulateur de calcul Azure à partir de Visual Studio pour travailler avec l'exemple de code, il n'est pas nécessaire d'exécuter la partie de la commande de démarrage qui installe les bibliothèques d'exécution Visual C++ ; c'est pourquoi vous devez ajouter une marque de commentaire à la ligne suivante dans le fichier startup.cmd :

REM "%~dps0vcredist_x64.exe" /q /norestart

L'exemple de code contient un projet qui crée une DLL native appelée ExampleNativeCode.dll. Il a été compilé en tant que bibliothèque 64 bits en mode Version finale, comme recommandé.

noteRemarque
Quittez et redémarrez l'émulateur de calcul Azure chaque fois que vous exécutez un exemple de code si des modifications sont apportées au code ou à des variables d'environnement Windows. Cela garantit que tout code natif référencé est libéré de la mémoire afin de pouvoir être recompilé et pour s'assurer que toutes les modifications de variable d'environnement sont prises en compte par l'émulateur de calcul Azure lors de la prochaine exécution.

L'exemple de code ExampleNativeCode.dll est encapsulé avec P/Invoke dans un projet appelé ManagedUsingPinvoke et encapsulé avec C++/CLI dans un projet appelé ManagedUsingCppCLI.

Le code de la DLL native est une version modifiée du modèle de projet par défaut Win32 avec des exportations et contient une seule fonction qui répond à toutes les questions connues au niveau mondial, dans la mesure où la réponse auxdites questions est le nombre 42 :

EXAMPLENATIVECODE_API int fnExampleNativeCode(void)
{
    return 42;
}

Le code P/Invoke et le code C++/CLI qui utilisent cette fonction sont très similaires :

P/Invoke

public class Class1
{
    [DllImport("ExampleNativeCode.dll")]
    static extern int fnExampleNativeCode();

    public int GetTheAnswerToEverything()
    {
        return fnExampleNativeCode();
    }
}

C++/CLI

public ref class Class1
{
public:

    int GetTheAnswerToEverything()
    {
        return fnExampleNativeCode();
    }
};

Les deux exemples de rôle de travail (PInvokeWorkerRole et CppCliWorkerRole) de la solution appellent le code de la même manière :

try
{
    Trace.WriteLine(new Class1().GetTheAnswerToEverything());
}
catch (Exception ex)
{
    Trace.WriteLine(ex);
}

Les deux exemples de rôle de travail incluent le code natif compilé et sont configurés pour toujours copier le code natif compilé dans le répertoire de sortie.

Lorsque vous appuyez sur la touche F5 pour exécuter le code dans l'émulateur de calcul Azure, vous devez voir le résultat suivant :

Certaines considérations s'appliquent lors de l'appel de code natif depuis des applications Azure s'exécutant dans une instance de rôle Web par rapport à une exécution dans une instance de rôle de travail. Les projets PInvokeWebRole et CppCliWebRole contiennent le code suivant dans une version légèrement modifiée du modèle de projet par défaut ASP.NET :

P/Invoke

<p>
    This is PInvoke <br />
        <%=Environment.GetEnvironmentVariable("PATH") %> <br />
        <%=new Class1().GetTheAnswerToEverything() %>
</p>

C++/CLI

<p>
    This is C++/CLI <br />
        <%=Environment.GetEnvironmentVariable("PATH") %> <br />
        <%=new Class1().GetTheAnswerToEverything() %>
</p>

L'exécution du projet PInvokeWebRole donne le résultat attendu, similaire à ce qui suit :

Toutefois, l'exécution du projet CppCliWebRole sans modification provoque l'erreur suivante :

noteRemarque
Cette erreur se produit même si les paramètres appropriés du projet ont été appliqués pour copier le code natif compilé dans le répertoire de sortie.

Pour résoudre cette erreur, utilisez l'une des méthodes décrites dans Ensure that Azure Applications Running in a Web Role Instance can Locate any Referenced Native Code. Après avoir utilisé l'une de ces méthodes vous devez voir le résultat attendu pour la page CppCliWebRole, similaire à ce qui suit :

Afficher:
© 2014 Microsoft