Exportieren (0) Drucken
Alle erweitern

Speicherkontenschlüssel neu generieren

Letzte Aktualisierung: Februar 2015

Durch den asynchronen Regenerate Keys-Vorgang werden der primäre oder der sekundäre Zugriffsschlüssel für das angegebene Speicherkonto erneut generiert.

Die Regenerate Keys-Anforderung kann wie folgt angegeben werden. Ersetzen Sie <subscription-id> durch Ihre Abonnement-ID und <service-name> durch den Namen des gewünschten Speicherkontos.

 

Methode Anforderungs-URI

POST

https://management.core.windows.net/<subscription-id>/services/storageservices/<service-name>/keys?action=regenerate

Sie müssen sicherstellen, dass die an den Verwaltungsdienst gestellte Anforderung sicher ist. Zusätzliche Informationen finden Sie im Thema Authentifizieren von Dienstverwaltungsanforderungen.

 

URI-Parameter Beschreibung

action=regenerate

Erforderlich. Gibt an, dass der primäre oder sekundäre Zugriffsschlüssel für das angegebene Speicherkonto erneut generiert werden muss.

In der folgenden Tabelle werden die Anforderungsheader beschrieben.

 

Anforderungsheader Beschreibung

Content-Type

Erforderlich. Legen Sie diesen Header auf application/xml fest.

x-ms-version

Erforderlich. Gibt die Version des für die Anforderung zu verwendenden Vorgangs an. Dieser Header sollte auf 01.10.09 oder höher festgelegt werden. Weitere Informationen zu den Versionsangaben in den Headern finden Sie unter Dienstverwaltungs-Versionsverwaltung.

Der Anforderungstext zeigt an, welcher Schlüssel erneut generiert werden soll, der primäre oder der sekundäre Schlüssel. Der Anforderungstext weist das folgende Format auf:


<?xml version="1.0" encoding="utf-8"?>
<RegenerateKeys xmlns="http://schemas.microsoft.com/windowsazure">
  <KeyType>Primary|Secondary</KeyType>
</RegenerateKeys>

In der folgenden Tabelle werden die Elemente des Anforderungstexts beschrieben.

 

Name des Elements Beschreibung

KeyType

Gibt an, welcher Schlüssel erneut generiert werden soll. Gültige Werte:

  • Primär

  • Sekundär

Die Antwort enthält den HTTP-Statuscode, einen Satz von Antwortheadern und einen Antworttext.

Bei einem erfolgreichen Vorgang wird der Statuscode 200 (OK) zurückgegeben. Weitere Informationen zu Statuscodes finden Sie unter Dienstverwaltungsstatus und Fehlercodes.

Die Antwort für diesen Vorgang umfasst die folgenden Header. Die Antwort kann außerdem weitere HTTP-Standardheader enthalten. Alle Standardheader entsprechen der HTTP/1.1-Protokollspezifikation.

 

Antwortheader Beschreibung

x-ms-request-id

Ein Wert, der eine für den Verwaltungsdienst ausgeführte Anforderung eindeutig identifiziert. Bei einem asynchronen Vorgang können Sie Vorgangsstatus abrufen mit dem Wert dieses Headers aufrufen, um zu bestimmen, ob der Vorgang abgeschlossen wurde, fehlgeschlagen ist oder noch ausgeführt wird.

Die Antwort gibt den primären und den sekundären Zugriffsschlüssel zurück. Der Antworttext weist das folgende Format auf:


<?xml version="1.0" encoding="utf-8"?>
  <StorageService xmlns="http://schemas.microsoft.com/windowsazure">
    <Url>storage-service-request-uri</Url>
    <StorageServiceKeys>
      <Primary>primary-key</Primary>
      <Secondary>secondary-key</Secondary>
    </StorageServiceKeys>
  </StorageService>

In der folgenden Tabelle sind die Elemente des Antworttexts beschrieben:

 

Name des Elements Beschreibung

Url

Der Anforderungs-URI der Dienstverwaltungs-API, der für Speicherkonteneigenschaften abrufen-Anforderungen für das Speicherkonto verwendet wird.

Primär

Der primäre Schlüssel für das angegebene Speicherkonto.

Sekundär

Der sekundäre Schlüssel für das angegebene Speicherkonto.

Mit dem Regenerate Storage Account Keys-Vorgang wird der primäre oder der sekundäre Schlüssel für einen Speicherkontodienst erneut generiert. Dieser Vorgang kann mit den vom Speicherkonten auflisten-Vorgang zurückgegebenen Speicherkonten verwendet werden, um die Verwaltung von Speicherschlüsselupdates zu automatisieren.

Im folgenden Beispielprogramm werden die Abonnement-ID, ein zugeordneter Verwaltungszertifikatfingerabdruck, die Versionszeichenfolge des Vorgangs und ein Speicherkontoname verwendet und die zurückgegebenen Speicherkonto-Zugriffsschlüssel auf der Konsole ausgegeben. Anschließend wir der Regenerate Storage Account Keys-Vorgang aufgerufen, um die sekundäre Tastenkombination für das Speicherkonto erneut zu generieren, und die neuen Schlüsselergebnisse werden gedruckt. Initialisieren Sie die Konstante Version mit einer Versionsheaderzeichenfolge, SubscriptionId mit dem GUID-Bezeichner für das Abonnement, Thumbprint mit dem Verwaltungszertifikat-Fingerabdruckwert und ServiceName mit dem Namen Ihres Speicherkontos, um den Beispielcode auszuführen.

namespace Microsoft.WindowsAzure.ServiceManagementRESTAPI.Samples
{
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Net;
    using System.Security.Cryptography.X509Certificates;
    using System.Xml;
    using System.Xml.Linq;
 
    public class Program
    {
        // Set these constants with your values to run the sample.
        private const string Version = "2011-10-01";
        private const string Thumbprint = "management-certificate-thumbprint";
        private const string SubscriptionId = "subscription-id-guid";
        private const string ServiceName = "storage-account-name";
 
        // This is the common namespace for all Service Management REST API XML data.
        private static XNamespace wa = "http://schemas.microsoft.com/windowsazure";
 
        /// <summary>
        /// Gets or sets the certificate that matches the Thumbprint value.
        /// </summary>
        private static X509Certificate2 Certificate { get; set; }
 
        static void Main(string[] args)
        {
            try
            {
                Certificate = GetCertificate(Thumbprint);
 
                XElement initialKeys = 
                    GetStorageAccountKeys(SubscriptionId, ServiceName);
                Console.WriteLine(
                    "Storage Account Keys for {0}:{1}{2}",
                    ServiceName, 
                    Environment.NewLine,
                    initialKeys.ToString(SaveOptions.OmitDuplicateNamespaces));
 
                string keyType = "Secondary";
                XElement regeneratedKeys =
                    RegenerateStorageAccountKeys(SubscriptionId, ServiceName, keyType);
                Console.WriteLine(
                    "Regenerated {0} Storage Account Key for {1}:{2}{3}",
                    keyType, 
                    ServiceName, 
                    Environment.NewLine,
                    regeneratedKeys.ToString(SaveOptions.OmitDuplicateNamespaces));
            }
            catch (Exception ex)
            {
                Console.WriteLine("Exception caught in Main:");
                Console.WriteLine(ex.Message);
            }
 
            Console.Write("Press any key to continue:");
            Console.ReadKey();
        }
 
        /// <summary>
        /// Gets the certificate matching the thumbprint from the local store.
        /// Throws an ArgumentException if a matching certificate is not found.
        /// </summary>
        /// <param name="thumbprint">The thumbprint of the certificate to find.</param>
        /// <returns>The certificate with the specified thumbprint.</returns>
        private static X509Certificate2 GetCertificate(string thumbprint)
        {
            List<StoreLocation> locations = new List<StoreLocation> 
            { 
                StoreLocation.CurrentUser, 
                StoreLocation.LocalMachine 
            };
 
            foreach (var location in locations)
            {
                X509Store store = new X509Store("My", location);
                try
                {
                    store.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);
                    X509Certificate2Collection certificates = store.Certificates.Find(
                        X509FindType.FindByThumbprint, thumbprint, false);
                    if (certificates.Count == 1)
                    {
                        return certificates[0];
                    }
                }
                finally
                {
                    store.Close();
                }
            }
 
            throw new ArgumentException(string.Format(
                "A Certificate with Thumbprint '{0}' could not be located.",
                thumbprint));
        }
 
        /// <summary>
        /// Calls the Get Storage Account Keys operation in the Service Management
        /// REST API for the specified subscription and storage account name and returns
        /// the StorageService XML element from the response.
        /// </summary>
        /// <param name="subscriptionId">The subscription identifier.</param>
        /// <param name="serviceName">The name of the storage account.</param>
        /// <returns>The StorageService XML element from the response.</returns>
        private static XElement GetStorageAccountKeys(
            string subscriptionId,
            string serviceName)
        {
            string uriFormat = "https://management.core.windows.net/{0}" +
                "/services/storageservices/{1}/keys";
            Uri uri = new Uri(String.Format(uriFormat, subscriptionId, serviceName));
            XDocument responseBody;
            string requestId;
            HttpStatusCode statusCode = 
                InvokeRequest(uri, "GET", null, out responseBody, out requestId);
            VerifyResult(uri, statusCode, HttpStatusCode.OK, responseBody);
            return responseBody.Element(wa + "StorageService");
        }
 
        /// <summary>
        /// Calls the Regenerate Storage Account Keys operation in the Service 
        /// Management REST API for the specified subscription, storage account name, 
        /// and key, and returns the StorageService XML element from the response.
        /// </summary>
        /// <param name="subscriptionId">The subscription identifier.</param>
        /// <param name="serviceName">The name of the storage account.</param>
        /// <param name="keyType">A value of "Primary" or "Secondary" to specify the key to regenerate.</param>
        /// <returns>The StorageService XML element from the response.</returns>
        private static XElement RegenerateStorageAccountKeys(
            string subscriptionId,
            string serviceName,
            string keyType)
        {
            string uriFormat = "https://management.core.windows.net/{0}" +
                "/services/storageservices/{1}/keys?action=regenerate";
            Uri uri = new Uri(String.Format(uriFormat, subscriptionId, serviceName));
            XDocument requestBody = new XDocument(
                new XDeclaration("1.0", "UTF-8", "no"),
                new XElement(
                    wa + "RegenerateKeys",
                    new XElement(wa + "KeyType", keyType)));
            XDocument responseBody;
            string requestId;
            HttpStatusCode statusCode =
                InvokeRequest(uri, "POST", requestBody, out responseBody, out requestId);
            VerifyResult(uri, statusCode, HttpStatusCode.OK, responseBody);
            return responseBody.Element(wa + "StorageService");
        }
 
        /// <summary>
        /// A helper function to invoke a Service Management REST API operation.
        /// </summary>
        /// <param name="uri">The URI of the operation to invoke using a web request.</param>
        /// <param name="method">The method of the web request, GET, PUT, POST, or DELETE.</param>
        /// <param name="requestBody">The XML body to send with the web request. Use null to send no request body.</param>
        /// <param name="responseBody">The XML body returned by the request, if any.</param>
        /// <param name="requestId">The requestId returned by the request, if any.</param>
        /// <returns>The status code returned by the request.</returns>
        private static HttpStatusCode InvokeRequest(
            Uri uri,
            string method,
            XDocument requestBody,
            out XDocument responseBody,
            out string requestId)
        {
            responseBody = null;
            requestId = String.Empty;
 
            HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(uri);
            request.Method = method;
            request.Headers.Add("x-ms-Version", Version);
            request.ClientCertificates.Add(Certificate);
            request.ContentType = "application/xml";
 
            if (requestBody != null)
            {
                using (Stream requestStream = request.GetRequestStream())
                {
                    using (StreamWriter streamWriter = new StreamWriter(
                        requestStream, System.Text.UTF8Encoding.UTF8))
                    {
                        requestBody.Save(streamWriter, SaveOptions.DisableFormatting);
                    }
                }
            }
 
            HttpWebResponse response;
            HttpStatusCode statusCode = HttpStatusCode.Unused;
            try
            {
                response = (HttpWebResponse)request.GetResponse();
            }
            catch (WebException ex)
            {
                // GetResponse throws a WebException for 4XX and 5XX status codes
                response = (HttpWebResponse)ex.Response;
            }
            
            try
            {
                statusCode = response.StatusCode;
                if (response.ContentLength > 0)
                {
                    using (XmlReader reader = XmlReader.Create(response.GetResponseStream()))
                    {
                        responseBody = XDocument.Load(reader);
                    }
                }
 
                if (response.Headers != null)
                {
                    requestId = response.Headers["x-ms-request-id"];
                }
            }
            finally
            {
                response.Close();
            }
 
            return statusCode;
        }
 
        /// <summary>
        /// A helper function to throw an ApplicationException on unexpected 
        /// status code responses from Service Management REST API operation calls.
        /// </summary>
        /// <param name="uri">The URI of the Service Management operation.</param>
        /// <param name="statusCode">The status code returned by the operation.</param>
        /// <param name="expectedCode">The expected status code.</param>
        /// <param name="responseBody">The response body returned by the operation.</param>
        private static void VerifyResult(
            Uri uri,
            HttpStatusCode statusCode,
            HttpStatusCode expectedCode,
            XDocument responseBody)
        {
            if (!statusCode.Equals(expectedCode))
            {
                throw new ApplicationException(string.Format(
                    "Call to {0} returned an error:{1}Status Code: {2} ({3}):{1}{4}",
                    uri.ToString(),
                    Environment.NewLine,
                    (int)statusCode,
                    statusCode,
                    responseBody.ToString(SaveOptions.OmitDuplicateNamespaces)));
            }
 
            return;
        }
    }
}

Dieses Beispielprogramm generiert Ergebnisse ähnlich den folgenden:

Storage Account Keys for myexamplestorage1:
<StorageService xmlns="http://schemas.microsoft.com/windowsazure" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
  <Url>https://management.core.windows.net/01234567-89ab-cdef-0123-456789abcdef/services/storageservices/myexamplestorage1</Url>
  <StorageServiceKeys>
    <Primary>XrmGWqu6qpgKX5G3lf+V5Bc0nFIGjGWiWhHTdMxkA5Mb4WjJ0rDV+3USWW/9fAWCrszrkr8+JUb1c5mxQdq4nw==</Primary>
    <Secondary>7jGHqUXHfASoUWeuClG9TXRZ59tTl5Fep8BNi5f86LFuewc0dQjDc6pyyju8BOi5947byrtgKnVtYO4f4cVdcg==</Secondary>
  </StorageServiceKeys>
</StorageService>
Regenerated Secondary Storage Account Key for myexamplestorage1:
<StorageService xmlns="http://schemas.microsoft.com/windowsazure" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
  <Url>https://management.core.windows.net/01234567-89ab-cdef-0123-456789abcdef/services/storageservices/myexamplestorage1</Url>
  <StorageServiceKeys>
    <Primary>XrmGWqu6qpgKX5G3lf+V5Bc0nFIGjGWiWhHTdMxkA5Mb4WjJ0rDV+3USWW/9fAWCrszrkr8+JUb1c5mxQdq4nw==</Primary>
    <Secondary>2Wd7lP3MesbkFi0LAltwUd40L6uu85N9VBtokOo2RfpqKA8q39orkJ6WUV3jP4TkZuYrSQNYxkQ5axcSzzTu8A==</Secondary>
  </StorageServiceKeys>
</StorageService>
Press any key to continue:

Anzeigen:
© 2015 Microsoft