(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde noch nicht bewertet - Dieses Thema bewerten.

Adapter für eine VM-Rolle in Windows Azure entwickeln

Letzte Aktualisierung: März 2011

[Die Funktion "VM-Rolle" von Windows Azure wird am 15.05.2013 außer Betrieb genommen. Nach diesem Datum werden Bereitstellungen des Typs "VM-Rolle" gelöscht. Mit "Windows Azure-Virtuelle Computer" können Sie Ihre vorhandenen Anwendungen weiterhin nutzen. Weitere Informationen über die Verwendung von "Virtuelle Computer" für eine Anwendung finden Sie unter Moving from VM Role to Windows Azure Virtual Machines (Wechseln von "VM-Rolle" zu "Windows Azure-Virtuelle Computer").

Sie können einen Adapter als Windows-Dienst schreiben, der automatisch startet, wenn das Betriebssystem gestartet wird, und die Microsoft.WindowsAzure.ServiceRuntime-API für Laufzeitinformationen von Windows Azure verwendet. Sie müssen möglicherweise einen Windows-Dienst schreiben, wenn Sie Netzwerkadresseninformationen für die aktuelle VM-Rolleninstanz oder andere im Dienst ausgeführte Rolleninstanzen benötigen, wenn Sie in eine lokale Speicherressource schreiben möchten oder wenn Sie Dienstkonfigurationseinstellungen zur Laufzeit lesen oder bei Änderungen antworten müssen.

In diesem Abschnitt wird beschrieben, wie ein Adapter erstellt wird, der Dienste zur Unterstützung einer VM-Rolle enthält. In dem Beispiel, das in diesem Abschnitt verwendet wird, wird ein Windows Azure-Laufwerk eingebunden, wenn das Betriebssystem gestartet wird, und anschließend Internet Information Services (IIS) konfiguriert, um HTTP-Protokolldateien auf das Laufwerk zu schreiben.

Zum Erstellen eines Adapters müssen Sie die folgenden Tasks ausführen:

  1. Speichercontainer erstellen

  2. Adapterprojekt erstellen

  3. Option hinzufügen, Änderungen der Rolleninstanzkonfiguration nachzuverfolgen

  4. Definieren, was beim Starten des Adapters geschieht

  5. Definieren, was beim Beenden des Adapters geschieht

  6. Installer für den Adapter erstellen

  7. Setup-Projekt für den Adapter erstellen

  8. Postbuildereignis zum Korrigieren von Assemblyinkonsistenzen hinzufügen

  9. Dem Cloud-Dienstmodell Konfigurationseinstellungen hinzufügen

  10. Adapter installieren

Der Adapter verwendet BLOB-Speicher, um das Speichern von Protokolldaten auf dem Windows Azure-Laufwerk zu erleichtern. Sie müssen Zugriff auf ein Speicherkonto in Windows Azure haben, und Sie müssen einen Container erstellen, der vom Adapter verwendet wird. Sie können Ihr bevorzugtes Tool zum Erstellen eines Containers im Windows Azure-Speicher mit einem beliebigen Namen verwenden. Sie verwenden den Namen des Containers, wenn Sie das Cloud-Dienstmodell konfigurieren.

Visual Studio 2010 stellt eine Vorlage zum Erstellen eines Windows-Diensts bereit. Sie können diese Vorlage verwenden, um den Adapter für die VM-Rolleninstanzen zu erstellen.

  1. Öffnen Sie Visual Studio 2010, klicken Sie auf Datei und anschließend auf Neu und Projekt.

  2. Klicken Sie im Bereich Installierte Vorlagen unter Visual C# auf Windows, und dann im mittleren Bereich auf Windows-Dienst.

  3. Geben Sie einen Namen für die Projektmappe und das Adapterprojekt ein, und klicken Sie dann auf OK.

  4. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Projektmappe, klicken Sie auf Konfigurations-Manager, stellen Sie sicher, dass Any CPU für das Projekt ausgewählt ist, und klicken Sie dann auf Schließen.

  5. Benennen Sie im Projektmappen-Explorer die Datei "Service1.cs" auf den Namen um, den Sie für den Adapter verwenden. In den Beispielen in diesem Abschnitt wird der Platzhalter AdapterName verwendet, der den Namen darstellt, den Sie auswählen.

  6. Klicken Sie mit der rechten Maustaste auf das Projekt, klicken Sie auf Eigenschaften, und stellen Sie auf der Anwendungsseite sicher, dass .NET Framework 3.5 als Zielframework ausgewählt ist.

  7. Klicken Sie auf der Seite "Veröffentlichen" der Projekteigenschaften auf Erforderliche Komponenten, und stellen Sie sicher, dass .NET Framework 4 (Clientprofil) nicht ausgewählt ist.

  8. Fügen Sie im Projektmappen-Explorer Verweise für die folgenden Assemblys hinzu:

    • Microsoft.WindowsAzure.ServiceRuntime.dll

      noteHinweis
      Sie müssen sicherstellen, dass die Eigenschaft Lokal kopieren für diese Assembly auf False festgelegt ist.

    • Microsoft.WindowsAzure.CloudDrive.dll

    • Microsoft.WindowsAzure.StorageClient.dll

    • Microsoft.Web.Administration.dll

  9. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf AdapterName.cs, und klicken Sie dann auf Code anzeigen.

  10. Fügen Sie mithilfe von Anweisungen Folgendes hinzu:

    
    using Microsoft.WindowsAzure.ServiceRuntime;
    using Microsoft.WindowsAzure.StorageClient;
    using Microsoft.WindowsAzure;
    using Microsoft.Web.Administration;
    using System.IO;
    using System.Threading;
    
  11. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf AdapterName.cs, und klicken Sie dann auf Sicht-Designer.

  12. Legen Sie im Bereich Eigenschaften die folgenden Eigenschaften fest:

    • ServiceName: Sie können den Namen angeben, durch den der Adapter im System identifiziert wird.

    • (Name): Sie können den Namen angeben, der im Code verwendet wird, um das Adapterobjekt darzustellen.

    • CanShutdown: Sie müssen den Wert für diese Eigenschaft als True angeben, damit der Adapter benachrichtigt werden kann, wenn das System heruntergefahren wird.

Die Datei "Program.cs" enthält den folgenden Code:


static void Main()
{
   ServiceBase[] ServicesToRun;
   ServicesToRun = new ServiceBase[] 
   { 
      new ServiceName() 
   };  
   ServiceBase.Run(ServicesToRun);
}

Sie können Vorgänge definieren, die ausgeführt werden, wenn die Konfiguration einer Rolleninstanz geändert wird. Beispielsweise können Sie den Speicherort eines Laufwerks ändern, auf dem Protokollierungsdaten gespeichert werden, indem Sie die Konfiguration der Rolleninstanz ändern. Zu diesem Zweck können Sie die RoleEnvironment-Ereignisse verwenden.

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf AdapterName.cs, und klicken Sie dann auf Code anzeigen.

  2. Bearbeiten Sie den Konstruktor, um die Ereignisse, die die Konfiguration ändern, zu definieren. Im folgenden Codebeispiel werden die Ereignisdefinitionen veranschaulicht, die dem Konstruktor hinzugefügt werden:

    
    public AdapterName()
    {
       InitializeComponent();
       RoleEnvironment.Changed += RoleEnvironmentChanged;
       RoleEnvironment.StatusCheck += RoleEnvironmentStatusCheck;
    }
    
  3. Fügen Sie die RoleEnvironmentChanged-Methode hinzu, die aufgerufen wird, wenn das geänderte Ereignis auftritt. Im folgenden Codebeispiel wird die RoleEnvironmentChanged-Methode dargestellt, die ein neues Windows Azure-Laufwerk einbindet und IIS konfiguriert, um Protokolldateien auf das neue Laufwerk zu schreiben:

    
    private CloudDrive currentDrive;
     
    private void RoleEnvironmentChanged(object sender, RoleEnvironmentChangedEventArgs e)
    {
       if(!e.Changes.OfType<RoleEnvironmentConfigurationSettingChange>().Any(
          c => c.ConfigurationSettingName == "AdapterName.BlobPath"))
          return;
    
       try
       {
          // perform a rolling drive change
          var oldDrive = this.currentDrive;
          var newDrive = MountDrive();
          try
          {
             ConfigureWebServer(newDrive.LocalPath);
          }
          catch (Exception)
          {
             UnmountDrive(newDrive);
             throw;
          }
          this.currentDrive = newDrive;
          UnmountDrive(oldDrive);
       }
       catch (Exception ex)
       {
          this.EventLog.WriteEntry(ex.ToString(), EventLogEntryType.Error);
          throw;
       }
    }
    

    Dabei ist AdapterName der Name, den Sie für das Adapterprojekt angegeben haben.

  4. Fügen Sie die Methoden hinzu, die das Windows Azure-Laufwerk einbinden und die Einbindung aufheben, und fügt die Methode hinzu, um den Speicherort der Protokolldatei für IIS zu konfigurieren. Im folgenden Codebeispiel wird die MountDrive-Methode veranschaulicht:

    
    private CloudDrive MountDrive()
    {
       // create or mount an instance-specific drive
       var credentials = GetStorageCredentials();
       var driveUri = GetDriveUri();
       var drive = new CloudDrive(driveUri, credentials);
    
       try
       {
          drive.Create(1024);
       }
       catch (Exception ex)
       {
          if (ex.Message != "ERROR_BLOB_ALREADY_EXISTS") throw;
       }
    
       // mount the drive
       string mountPoint = drive.Mount(1024, 
          DriveMountOptions.FixFileSystemErrors | DriveMountOptions.Force);
       this.EventLog.WriteEntry(string.Format("{0} mounted at {1}", drive.Uri, mountPoint));
       return drive;
    }
    
    private Uri GetDriveUri()
    {
       return new Uri(string.Format(
       RoleEnvironment.GetConfigurationSettingValue("AdapterName.BlobPath"),
          RoleEnvironment.CurrentRoleInstance.Id));
    }
    
    private StorageCredentials GetStorageCredentials()
    {
       return new StorageCredentialsAccountAndKey(
       RoleEnvironment.GetConfigurationSettingValue("AdapterName.AccountName"),
       RoleEnvironment.GetConfigurationSettingValue("AdapterName.AccountKey"));
    }
    

    Weitere Informationen zum Verwenden der CloudDrive-API finden Sie unter CloudDrive. Die Einstellungen für AdapterName.BlobPath, AdapterName.AccountName und AdapterName.AccountKey werden in der Cloud-Dienst-Definitionsdatei definiert und in der Dienstkonfigurationsdatei konfiguriert. Weitere Informationen zum Definieren dieser Einstellungen finden Sie unter Dem Cloud-Dienstmodell Konfigurationseinstellungen hinzufügen.

    Im folgenden Codebeispiel wird die UnmountDrive-Methode veranschaulicht:

    
    private void UnmountDrive(CloudDrive drive)
    {
       drive.Unmount();
       this.EventLog.WriteEntry(string.Format("{0} unmounted", drive.Uri));
    }
    
    

    Im folgenden Codebeispiel wird die ConfigureWebServer-Methode veranschaulicht:

    
    private void ConfigureWebServer(string drivePath)
    {
       using (var config = new ServerManager())
       {
          var logdir = Path.Combine(drivePath, @"inetpub\logs\LogFiles");
          config.SiteDefaults.LogFile.Directory = logdir;
    
          config.CommitChanges();
    
          this.EventLog.WriteEntry(string.Format("IIS log location set to '{0}'", logdir));
       }
    }
    
    
  5. Fügen Sie die RoleEnvironmentStatusCheck-Methode hinzu, die verwendet wird, um den Status der Rolleninstanz zu bestimmen. Das statusCheckWaitHandle-Objekt wird als Signal verwendet, um dem Lastenausgleich mitzuteilen, dass die Rolleninstanz ausgelastet oder bereit ist. Der Aufruf der Set-Methode des Objekts ist das Signal, dass die Konfigurationsänderung abgeschlossen ist. Im folgenden Codebeispiel wird die RoleEnvironmentStatusCheck-Methode veranschaulicht:

    
    private readonly EventWaitHandle statusCheckWaitHandle = new ManualResetEvent(false);
    private volatile bool busy = true;
    
    private void RoleEnvironmentStatusCheck(object sender, RoleInstanceStatusCheckEventArgs e)
    {
       if (this.busy)
       {
          e.SetBusy();
       }
       statusCheckWaitHandle.Set();
    }
    
    

In diesem Beispiel führt der Adapter beim Starten die folgenden Vorgänge aus:

  • Initialisieren des Laufwerkscache

  • Einbinden des Laufwerks

  • Konfigurieren von IIS, um das eingebundene Laufwerk zu verwenden

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf AdapterName.cs, und klicken Sie dann auf Code anzeigen. Suchen Sie die OnStart-Methode, die beim Erstellen des Projekts automatisch überschrieben wurde, und fügen Sie den Code hinzu, der die Rolleninstanz überprüft, um deren Ausführung sicherzustellen, die Vorgänge des Adapters auf einem separaten Thread ausführt und dann mithilfe des statusCheckWaitHandle-Objekts signalisiert, dass die Vorgänge abgeschlossen sind.

    
    protected override void OnStart(string[] args)
    {
       /// Windows Azure waits for auto-start services to be fully started 
       /// before sending any traffic.  Service Control Manager (SCM) does
       /// not impose a time limit on startup; the service need only 
       /// request additional time.
    
       if (!RoleEnvironment.IsAvailable) return;
          
       var startThread = new Thread(OnStartInternal);
       startThread.Start();
    
       // wait until a status check has occurred, so that Windows Azure 
       // knows we are working on something.
       WaitForHandle(statusCheckWaitHandle);
    }
    

    Im folgenden Codebeispiel wird die OnStartInternal-Methode veranschaulicht, wobei das Windows Azure-Laufwerk eingebunden ist und die IIS-Konfiguration geändert wird, um das neue Laufwerk für das Schreiben von Protokolldaten zu verwenden:

    
    private void OnStartInternal()
    {
       try
       {
          // initialize the drive cache
          string cachePath = RoleEnvironment.GetLocalResource("Data").RootPath;
          CloudDrive.InitializeCache(cachePath, 4096);
          this.EventLog.WriteEntry("initialization succeeded");
    
          // mount the current drive
          this.currentDrive = MountDrive();
    
          // configure IIS
          ConfigureWebServer(this.currentDrive.LocalPath);
    
          this.busy = false;
       }
       catch (Exception ex)
       {
          this.EventLog.WriteEntry(ex.ToString(), EventLogEntryType.Error);
          throw;
       }
    }
    

    Im folgenden Codebeispiel wird die WaitForHandle-Methode veranschaulicht, die wartet, bis eine Statusüberprüfung auftritt:

    
    private const int ThreadPollTimeInMilliseconds = 1000;
    
    private void WaitForHandle(WaitHandle handle)
    {
       while (!handle.WaitOne(ThreadPollTimeInMilliseconds))
       {
          this.RequestAdditionalTime(ThreadPollTimeInMilliseconds * 2);
       }
    }
    

In diesem Beispiel konfiguriert der Adapter den Speicherort der Protokolldatei neu und hebt beim Beenden die Einbindung des Laufwerks auf.

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf AdapterName.cs, und klicken Sie dann auf Code anzeigen. Suchen Sie die OnStop-Methode, die beim Erstellen des Projekts automatisch überschrieben wurde, und fügen Sie den Code hinzu, der den Speicherort der Protokolldatei neu konfiguriert und die Einbindung des Laufwerks aufhebt.

    
    protected override void OnStop()
    {
       OnStopInternal();
    }
    
  2. Im folgenden Codebeispiel wird die OnShutdown-Methode veranschaulicht:

    
    protected override void OnShutdown()
    {
       /// Windows Azure stops sending traffic before shutting down.
       /// Note that some requests may still be executing.
       OnStopInternal();
    }
    
  3. Fügen Sie die OnStopInternal-Methode hinzu, bei der die Vorgänge ausgeführt werden.

    
    private void OnStopInternal()
    {
       try
       {
          ConfigureWebServer(@"%SystemDrive%");
    
          if (this.currentDrive != null)
          {
             UnmountDrive(this.currentDrive);
             this.currentDrive = null;
          }
       }
       catch (Exception ex)
       {
          this.EventLog.WriteEntry(ex.ToString(), EventLogEntryType.Error);
          throw;
       }
    }
    
    

Beim Installieren eines Windows-Diensts müssen bestimmte benutzerdefinierte Aktionen stattfinden, was durch die Installerklasse ausgeführt werden kann. Visual Studio kann diese Installer speziell für einen Windows-Dienst erstellen und dem Projekt hinzufügen.

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf AdapterName.cs, und wählen Sie dann Sicht-Designer aus.

  2. Klicken Sie auf den Hintergrund des Designers, um den Adapter selbst statt einen seiner Inhalte auszuwählen.

  3. Klicken Sie bei fokussiertem Designer mit der rechten Maustaste, und klicken Sie dann auf Installer hinzufügen.

    Standardmäßig wird eine Komponentenklasse, die zwei Installer enthält, dem Projekt hinzugefügt. Der Name der Komponente lautet ProjectInstaller, und die enthaltenen Installer sind der Installer für den Adapter und der Installer für den zugeordneten Prozess des Adapters.

  4. Klicken Sie in der Entwurfsansicht für ProjectInstaller auf serviceInstaller1.

  5. Legen Sie im Fenster Eigenschaften die ServiceName-Eigenschaft auf den Namen des Adapters fest.

  6. Legen Sie die StartType-Eigenschaft auf Automatisch fest.

  7. Klicken Sie im Designer auf serviceProcessInstaller1. Legen Sie die Account-Eigenschaft auf LocalService fest. Dies bewirkt, dass der Adapter installiert und für ein lokales Dienstkonto ausgeführt wird.

  8. Erstellen Sie das Projekt.

Ein Setup-Projekt installiert die kompilierten Projektdateien und führt die Installer aus, die zum Ausführen des Adapters erforderlich sind. Um ein vollständiges Setup-Projekt zu erstellen, müssen Sie die Projektausgabe dem Setup-Projekt hinzufügen und anschließend eine benutzerdefinierte Aktion zum Installieren des Programms hinzufügen.

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste, um die Projektmappe auszuwählen, zeigen Sie auf Hinzufügen, und klicken Sie dann auf Neues Projekt.

  2. Erweitern Sie im Bereich Installierte Vorlagen die Option Andere Projekttypen, erweitern Sie Setup und Bereitstellungsprojekte, und klicken Sie dann auf Visual Studio Installer.

  3. Klicken Sie im mittleren Bereich auf Setup-Projekt.

  4. Geben Sie einen Namen für das Setup-Projekt ein, und klicken Sie dann auf OK.

  5. Erweitern Sie Gefundene Abhängigkeiten, doppelklicken Sie auf Microsoft .NET Framework, und stellen Sie dann im Bereich Eigenschaften sicher, dass .NET Framework 3.5 der Wert für Version ist.

  6. Klicken Sie unter Gefundene Abhängigkeiten für jede der folgenden Assemblys mit der rechten Maustaste auf die Assembly, und klicken Sie dann auf Ausschließen:

    • Microsoft.Web.Administration.dll

    • Microsoft.WindowsAzure.ServiceRuntime.dll

    • msshrtmi.dll

    • mswacdmi.dll

Fügen Sie nun eine benutzerdefinierte Aktion hinzu, um die Programmdatei für den Adapter zu installieren.

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Setup-Projekt, zeigen Sie auf Anzeigen, und klicken Sie dann auf Benutzerdefinierte Aktionen.

  2. Klicken Sie im Editor Benutzerdefinierte Aktionen auf den Knoten Benutzerdefinierte Aktionen, und wählen Sie dann Benutzerdefinierte Aktion hinzufügen aus.

  3. Doppelklicken Sie im Listenfeld auf Anwendungsordner, um diesen zu öffnen, und wählen Sie dann Ausgabe hinzufügen aus.

  4. Wählen Sie im Fenster Projektausgabegruppe hinzufügen die Option Primäre Ausgabe aus, wählen Sie (Aktiv) für die Konfiguration aus, und klicken Sie dann auf OK.

Da in Visual Studio 32-Bit-Assemblys in die MSI-Datei eingefügt werden, Windows Azure jedoch 64-Bit-Assemblys erfordert, muss ein Skript ausgeführt werden, um die inkonsistenten Assemblys zu korrigieren. Sie können eine JavaScript-Datei als Postbuildereignis verwenden, um die Assemblys zu korrigieren.

  1. Speichern Sie den folgenden Code in der Datei FixMSI.js im Stammordner des Setup-Projekts:

    
    // workaround for "BadImageFormatException" issue - see http://msdn.microsoft.com/de-de/library/kz0ke5xt.aspx
    
    var msiOpenDatabaseModeTransact = 1;
    var msiViewModifyInsert = 1
    var msiViewModifyUpdate = 2
    var msiViewModifyAssign = 3
    var msiViewModifyReplace = 4
    var msiViewModifyDelete = 6
    
    var filespec = WScript.Arguments(0);
    var frameworkpath = WScript.Arguments(1);
    var installer = WScript.CreateObject("WindowsInstaller.Installer");
    var database = installer.OpenDatabase(filespec, msiOpenDatabaseModeTransact);
    
    WScript.Echo("Updating file '" + filespec + "' to use a 64-bit custom action...");
    
    Update64Bit();
    
    database.Commit();
    database = null;
    installer = null;
    
    function Update64Bit() {
        var sql;
        var view;
        var record;
        sql = "SELECT * FROM Binary WHERE `Name`='InstallUtil'";
        view = database.OpenView(sql);
        view.Execute();
        record = view.Fetch();
        if (record != null) {
            var dataCol = 2;
            record.SetStream(dataCol, frameworkpath + "\\InstallUtilLib.dll");
            view.Modify(msiViewModifyUpdate, record);
        }
        record = null;
        view.close();
        view = null;
    }
    
  2. Klicken Sie im Projektmappen-Explorer auf das zuvor erstellte Setup-Projekt, und fügen Sie dann im Bereich Eigenschaften der Eigenschaft PostBuildEvent den folgenden Befehl hinzu:

    
    cd $(ProjectDir) 
    CScript //NoLogo FixMSI.js "$(BuiltOutputPath)" "%SystemRoot%\Microsoft.NET\Framework64\v2.0.50727"
    
  3. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Setup-Projekt, und klicken Sie dann auf Erstellen.

Damit der Adapter mit Windows Azure kommunizieren kann, müssen Einstellungen im Cloud-Dienstmodell definiert werden.

  1. Öffnen Sie die Datei "ServiceDefinition.csdef" für die VM-Rolle.

  2. Fügen Sie dem ConfigurationSettings-Element die folgenden Einstellungen hinzu:

    
    <Setting name="AdapterName.BlobPath" />
    <Setting name="AdapterName.AccountName" />
    <Setting name="AdapterName.AccountKey" />
    

    Dabei ist AdapterName der Name des Adapterprojekts.

  3. Fügen Sie dem LocalResources-Element die folgende Einstellung hinzu:

    
    <LocalStorage name="Data" />
    

    Weitere Informationen zu den Elementen, die im Dienstmodell verwendet werden können, finden Sie unter VirtualMachineRole Schema.

  4. Speichern Sie die Datei.

  1. Öffnen Sie die Datei "ServiceConfiguration.cscfg" für die VM-Rolle.

  2. Fügen Sie der Datei die folgenden Konfigurationseinstellungen hinzu:

    
    <Setting name="AdapterName.BlobPath" value="http://StorageAccountName.blob.core.windows.net/ContainerName/{0}.vhd" />
    <Setting name="AdapterName.AccountName" value="StorageAccountName" />
    <Setting name="AdapterName.AccountKey" value="StorageAccountKey" />
    

    Dabei ist AdapterName des Name des Adapterprojekts, das Sie erstellt haben. StorageAccountName ist der Name des Speicherkontos. StorageAccountKey ist der Primärschlüssel des Speicherkontos. ContainerName ist der Speichercontainer, den Sie zuvor erstellt haben. Weitere Informationen zur Konfiguration des Dienstmodells finden Sie unter Windows Azure Service Configuration Schema. Weitere Informationen zum Definieren und Konfigurieren von Einstellungen finden Sie unter VM-Rolle-Dienstmodell erstellen und bereitstellen.

  3. Speichern Sie die Datei.

Der Adapter kann jetzt auf der VHD installiert werden, die Sie in Windows Azure hochladen.

Nachdem der Code erstellt wurde und die Einstellungen im Dienstmodell definiert und konfiguriert sind, können Sie den Adapter installieren und das Dienstmodellpaket bereitstellen. Für eine VM-Rolle wird der Adapter auf dem virtuellen Computer installiert, nachdem die Windows Azure-Integrationskomponenten installiert wurden.

Damit der Adapter ordnungsgemäß funktioniert, müssen mehrere Betriebssystemfunktionen aktiviert werden. Führen Sie für das Abbild, das Sie in Windows Azure hochladen, den folgenden Befehl aus:

DISM /Online /Enable-Feature /FeatureName:NetFx3 /FeatureName:IIS-WebServerRole /FeatureName:IIS-WebServer /FeatureName:IIS-CommonHttpFeatures /FeatureName:IIS-HttpErrors /FeatureName:IIS-ApplicationDevelopment /FeatureName:IIS-HealthAndDiagnostics /FeatureName:IIS-HttpLogging /FeatureName:IIS-RequestMonitor /FeatureName:IIS-Security /FeatureName:IIS-RequestFiltering /FeatureName:IIS-Performance /FeatureName:IIS-WebServerManagementTools /FeatureName:IIS-StaticContent /FeatureName:IIS-DefaultDocument /FeatureName:IIS-DirectoryBrowsing /FeatureName:IIS-HttpCompressionStatic /FeatureName:IIS-ManagementConsole

Navigieren Sie zum Installieren des Adapters zu dem Ordner, der die MSI-Datei enthält, und doppelklicken Sie auf die Datei. Diese Datei befindet sich im Ordner "Debuggen" des Setup-Projekts, das Sie zuvor erstellt haben.

Siehe auch

Fanden Sie dies hilfreich?
(1500 verbleibende Zeichen)
Vielen Dank für Ihr Feedback.

Community-Beiträge

Anzeigen:
© 2014 Microsoft. Alle Rechte vorbehalten.