Speicherkonto erstellen
Die Create Storage Account asynchroner Vorgang erstellt ein neues Speicherkonto in Microsoft Azure.
Anforderung
Die Create Storage Account -Anforderung kann wie folgt angegeben werden. Ersetzen Sie <subscription-id> durch Ihre Abonnement-ID.
| Methode | Anforderungs-URI |
|---|---|
| POST | https://management.core.windows.net/<subscription-id>/services/storageservices |
Sie müssen sicherstellen, dass die an den Verwaltungsdienst gestellte Anforderung sicher ist. Weitere Informationen finden Sie unter Authentifizieren von Dienstverwaltungsanforderungen.
URI-Parameter
Keine.
Anforderungsheader
In der folgenden Tabelle werden die Anforderungsheader beschrieben.
| Anforderungsheader | Beschreibung |
|---|---|
Content-Type |
Erforderlich. Legen Sie diesen Header auf Application/Xml. |
x-ms-version |
Erforderlich. Gibt die Version des für die Anforderung zu verwendenden Vorgangs an. Der Wert dieses Headers muss festgelegt werden, um 2011-06-01 oder höher. Weitere Informationen zu versionsverwaltungsheadern finden Sie unter Service-Versionsverwaltung. |
Anforderungstext
Der Anforderungstext weist das folgende Format auf:
<?xml version="1.0" encoding="utf-8"?> <CreateStorageServiceInput xmlns="https://schemas.microsoft.com/windowsazure"> <ServiceName>name-of-storage-account</ServiceName> <Description>description-of-storage-account</Description> <Label>base64-encoded-label</Label> <AffinityGroup>name-of-affinity-group</AffinityGroup> <Location>location-of-storage-account</Location> <GeoReplicationEnabled>geo-replication-indicator</GeoReplicationEnabled> <ExtendedProperties> <ExtendedProperty> <Name>property-name</Name> <Value>property-value</Value> </ExtendedProperty> </ExtendedProperties> <SecondaryReadEnabled>secondary-read-indicator</SecondaryReadEnabled> <AccountType>type-of-storage-account</AccountType> </CreateStorageServiceInput>
In der folgenden Tabelle werden die Elemente des Anforderungstexts beschrieben.
| Name des Elements | Beschreibung |
| Dienstname | Erforderlich. Ein Name für das Speicherkonto, das in Azure eindeutig ist. Speicherkontonamen müssen zwischen 3 und 24 Zeichen lang sein und dürfen nur Ziffern und Kleinbuchstaben enthalten. Dieser Name ist der DNS-Präfixname und kann verwendet werden, um auf BLOBs, Warteschlangen und Tabellen im Speicherkonto zuzugreifen. Beispiel: http://ServiceName.blob.core.windows.net/mycontainer/ |
| Label | Erforderlich. Eine Bezeichnung für das angegebene Speicherkonto als Base-64-codierte Zeichenfolge. Die Bezeichnung kann bis zu 100 Zeichen lang sein. Die Bezeichnung kann verwendet werden, um das Speicherkonto für die Nachverfolgung zu identifizieren. |
| Beschreibung | Optional. Eine Beschreibung des Speicherkontos. Die Beschreibung kann bis zu 1024 Zeichen lang sein. |
| Speicherort | Erforderlich, wenn AffinityGroup wurde nicht angegeben. Der Speicherort, an dem das Speicherkonto erstellt wird. Sie können entweder Einschließen einer Speicherort oder AffinityGroup Element im Hauptteil der Anforderung, aber nicht beide. Liste der verfügbaren Standorte, verwenden Sie die Standorte auflisten Vorgang. |
| AffinityGroup | Erforderlich, wenn Speicherort wurde nicht angegeben. Der Name einer vorhandenen Affinitätsgruppe im angegebenen Abonnement. Sie können entweder Einschließen einer Speicherort oder AffinityGroup Element im Hauptteil der Anforderung, aber nicht beide. Verwenden Sie zum Auflisten der verfügbaren affinitätsgruppen der Affinitätsgruppen auflisten Vorgang. |
| GeoReplicationEnabled | Optional. Gibt an, ob das Speicherkonto mit aktivierter geografischer Replikation erstellt wird. Wenn das Element nicht im Hauptteil Anforderung enthalten ist, der Standardwert ist true. Wenn festgelegt true, die Daten im Speicherkonto werden repliziert, mehr als einem geografischen Standort, um Flexibilität bei schwerwiegenden Ausfällen zu aktivieren.Die GeoReplicationEnabled Element ist nur Version 2012-03-01 und höher verfügbar und ersetzt durch das AccountType-Element mit Version 2014-06-01 oder höher. |
| Name | Optional. Stellt den Namen einer erweiterten Speicherkontoeigenschaft dar. Jede erweiterte Eigenschaft muss sowohl einen definierten Namen als auch einen definierten Wert aufweisen. Sie können über maximal 50 erweiterte Eigenschaftsnamen/Wert-Paare verfügen. Die maximale Länge des Namenelements beträgt 64 Zeichen, nur alphanumerische Zeichen und Unterstriche im Namen sind gültig, und der Name muss mit einem Buchstaben beginnen. Der Versuch, andere Zeichen zu verwenden, den Namen mit einem anderen Zeichen als einem Buchstaben zu beginnen oder einen Namen einzugeben, der dem einer anderen erweiterten Eigenschaft desselben Speicherkontos entspricht, führt zu einem Fehler des Typs Statuscode 400 (ungültige Anforderung). Die Name -Element ist nur bei Version 2012-03-01 und höher verfügbar. |
| Wert | Optional. Stellt den Wert einer erweiterten Speicherkontoeigenschaft dar. Jede erweiterte Eigenschaft muss sowohl einen definierten Namen als auch einen definierten Wert aufweisen. Sie können über maximal 50 erweiterte Eigenschaftsnamen/Wertpaare verfügen, und jeder erweiterte Eigenschaftswert kann eine maximale Länge von 255 Zeichen aufweisen. Die Wert -Element ist nur bei Version 2012-03-01 und höher verfügbar. |
| SecondaryReadEnabled | Optional. Gibt an, dass sekundäres Lesen für das Speicherkonto aktiviert ist. Folgende Werte sind möglich: - true- falseDie SecondaryReadEnabled Element ist nur verfügbar, die mit Version 2013-11-01 oder höher und ersetzt durch das AccountType-Element mit Version 2014-06-01 oder höher. |
| AccountType | Gibt an, ob das Konto lokal redundanten, georedundanten oder zonenredundanten Speicher oder georedundanten Speicher mit Lesezugriff unterstützt. Folgende Werte sind möglich: - Standard_LRS- Standard_ZRS- Standard_GRS- Standard_RAGRS- Premium_LRSDas AccountType -Element ist nur bei Verwendung von Version 2014-06-01 oder höher verfügbar und ersetzt die Elemente SecondaryReadEnabled und GeoReplicationEnabled.Das Premium_LRS -Element ist nur bei Verwendung von Version 2014-10-01 oder höher verfügbar. Note: Ein Standard_ZRS Konto kann später in einen anderen Kontotyp geändert werden, und die anderen Kontotypen können nicht geändert werden, um Standard_ZRS. Das gleiche gilt für Premium_LRS Konten. |
Antwort
Die Antwort enthält den HTTP-Statuscode, einen Satz von Antwortheadern und einen Antworttext.
Statuscode
Bei einem erfolgreichen Vorgang wird der Statuscode 200 (OK) zurückgegeben. Informationen zu Statuscodes finden Sie unter Status- und Fehlercodes der Dienstverwaltung.
Antwortheader
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. Sie können für den asynchronen Vorgang aufrufen Vorgangsstatus abrufen mit dem Wert des Headers zu bestimmen, ob der Vorgang abgeschlossen ist, ist fehlgeschlagen oder wird noch ausgeführt. |
Antworttext
Keine.
Hinweise
Können Speicherkonten programmgesteuert mit den Speicherkonto erstellen Vorgang, den Grenzen, die im Abonnement verfügbar. Informationen zu den Grenzen, die im Zusammenhang mit Speicherkonten finden Sie unter Azure-Abonnement und Dienstbeschränkungen, Kontingente und Einschränkungen.
Der Vorgang gibt sofort eine Anforderungs-ID zurück, während die Speicherkontoerstellung asynchron durch Azure ausgeführt wird, da das Bereitstellen eines neuen Speicherkontos mehrere Minuten in Anspruch nehmen kann. Um herauszufinden, wenn die speicherkontoerstellung abgeschlossen ist, können Sie Abfragen der Vorgangsstatus abrufen Vorgang mit der Anforderung-ID. Zurückgegebene XML-Text mit einer Vorgang mit einer Status Element dem Wert haben, wird InProgress, Failed, oder Succeeded, abhängig von den Status der speicherkontoerstellung. Wenn Sie abrufen, bis der Status Failed oder Succeeded, die Vorgang Element enthält einen Statuscode in der StatusCode Element und fehlgeschlagene Vorgänge enthalten zusätzliche Fehlerinformationen in der Fehler Element.
Die Informationen im Azure Storage Skalierbarkeits- und Leistungsziele kann auch Ihnen beim Planen des Speicherbedarfs.
Beispiel
Dieses beispielhafte Konsolenprogramm erstellt ein neues Speicherkonto, Festlegen der Beschreibung, Bezeichnung, Speicherort und geografische Replikation Status mithilfe der Speicherkonto erstellen Vorgang dann fragt die Vorgangsstatus abrufen Vorgang mit der Anforderung-ID zurückgegeben, aus der Speicherkonto erstellen Vorgang, bis der Aufruf erfolgreich war, fehlgeschlagen ist, oder Abruf ein Timeout. Schließlich ruft er Speicherkonteneigenschaften abrufen um die Eigenschaften für das neue Speicherkonto anzuzeigen. Legen Sie den Wert für die x-ms-version -Header in die Version string, Ihre Abonnement-ID im SubscriptionId, Ihren verwaltungszertifikatfingerabdruck in Thumbprint, und legen Sie "ServiceName" auf einen eindeutigen speicherkontonamen zum Ausführen des Beispiels.
namespace Microsoft.WindowsAzure.ServiceManagementRESTAPI.Samples { using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Net; using System.Security.Cryptography.X509Certificates; using System.Threading; 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-12-01"; private const string Thumbprint = "management-certificate-thumbprint"; private const string SubscriptionId = "subscription-identifier"; private const string ServiceName = "unique-storage-account-name"; // This is the common namespace for all Service Management REST API XML data. private static XNamespace wa = "https://schemas.microsoft.com/windowsazure"; /// <summary> /// The operation status values from PollGetOperationStatus. /// </summary> private enum OperationStatus { InProgress, Failed, Succeeded, TimedOut } /// <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 = GetStoreCertificate(Thumbprint); // Create the new storage account with the following values: string description = "Description for my example storage account"; string label = "My example storage account label"; string location = "North Central US"; bool? enableGeoReplication = true; string requestId = CreateStorageAccount( ServiceName, description, label, null, location, enableGeoReplication); Console.WriteLine( "Called Create Storage Account operation: requestId {0}", requestId); // Loop on Get Operation Status for result of storage creation OperationResult result = PollGetOperationStatus( requestId, pollIntervalSeconds: 20, timeoutSeconds: 180); switch (result.Status) { case OperationStatus.TimedOut: Console.WriteLine( "Poll of Get Operation Status timed out: " + "Operation {0} is still in progress after {1} seconds.", requestId, (int)result.RunningTime.TotalSeconds); break; case OperationStatus.Failed: Console.WriteLine( "Failed: Operation {0} failed after " + "{1} seconds with status {2} ({3}) - {4}: {5}", requestId, (int)result.RunningTime.TotalSeconds, (int)result.StatusCode, result.StatusCode, result.Code, result.Message); break; case OperationStatus.Succeeded: Console.WriteLine( "Succeeded: Operation {0} completed " + "after {1} seconds with status {2} ({3})", requestId, (int)result.RunningTime.TotalSeconds, (int)result.StatusCode, result.StatusCode); break; } // Display the property values for the new storage account. // Convert the Label property to a readable value for display. XElement updatedProperties = GetStorageAccountProperties(ServiceName); XElement labelElement = updatedProperties.Descendants(wa + "Label").First(); labelElement.Value = labelElement.Value.FromBase64(); Console.WriteLine( "New Storage Account Properties for {0}:{1}{2}", ServiceName, Environment.NewLine, updatedProperties.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> /// Calls the Get Storage Account Properties 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="serviceName">The name of the storage account.</param> /// <returns>The StorageService XML element from the response.</returns> private static XElement GetStorageAccountProperties( string serviceName) { string uriFormat = "https://management.core.windows.net/{0}" + "/services/storageservices/{1}"; Uri uri = new Uri(String.Format(uriFormat, SubscriptionId, serviceName)); XDocument responseBody; InvokeRequest(uri, "GET", HttpStatusCode.OK, null, out responseBody); return responseBody.Element(wa + "StorageService"); } /// <summary> /// Calls the Create Storage Account operation in the Service Management /// REST API for the specified subscription, storage account name, /// description, label, location or affinity group, and geo-replication /// enabled setting. /// </summary> /// <param name="serviceName">The name of the storage account to update.</param> /// <param name="description">The new description for the storage account.</param> /// <param name="label">The new label for the storage account.</param> /// <param name="affinityGroup">The affinity group name, or null to use a location.</param> /// <param name="location">The location name, or null to use an affinity group.</param> /// <param name="geoReplicationEnabled">The new geo-replication setting, if applicable. /// This optional parameter defaults to null.</param> /// <returns>The requestId for the operation.</returns> private static string CreateStorageAccount( string serviceName, string description, string label, string affinityGroup, string location, bool? geoReplicationEnabled = null) { string uriFormat = "https://management.core.windows.net/{0}" + "/services/storageservices"; Uri uri = new Uri(String.Format(uriFormat, SubscriptionId)); // Location and Affinity Group are mutually exclusive. // Use the location if it isn't null or empty. XElement locationOrAffinityGroup = String.IsNullOrEmpty(location) ? new XElement(wa + "AffinityGroup", affinityGroup) : new XElement(wa + "Location", location); // Create the request XML document XDocument requestBody = new XDocument( new XDeclaration("1.0", "UTF-8", "no"), new XElement( wa + "CreateStorageServiceInput", new XElement(wa + "ServiceName", serviceName), new XElement(wa + "Description", description), new XElement(wa + "Label", label.ToBase64()), locationOrAffinityGroup)); // Add the GeoReplicationEnabled element if the version supports it. if ((geoReplicationEnabled != null) && (String.CompareOrdinal(Version, "2011-12-01") >= 0)) { requestBody.Element( wa + "CreateStorageServiceInput").Add( new XElement( wa + "GeoReplicationEnabled", geoReplicationEnabled.ToString().ToLowerInvariant())); } XDocument responseBody; return InvokeRequest( uri, "POST", HttpStatusCode.Accepted, requestBody, out responseBody); } /// <summary> /// Calls the Get Operation Status operation in the Service /// Management REST API for the specified subscription and requestId /// and returns the Operation XML element from the response. /// </summary> /// <param name="requestId">The requestId of the operation to track.</param> /// <returns>The Operation XML element from the response.</returns> private static XElement GetOperationStatus( string requestId) { string uriFormat = "https://management.core.windows.net/{0}" + "/operations/{1}"; Uri uri = new Uri(String.Format(uriFormat, SubscriptionId, requestId)); XDocument responseBody; InvokeRequest(uri, "GET", HttpStatusCode.OK, null, out responseBody); return responseBody.Element(wa + "Operation"); } /// <summary> /// The results from PollGetOperationStatus are passed in this struct. /// </summary> private struct OperationResult { // The status: InProgress, Failed, Succeeded, or TimedOut. public OperationStatus Status { get; set; } // The http status code of the requestId operation, if any. public HttpStatusCode StatusCode { get; set; } // The approximate running time for PollGetOperationStatus. public TimeSpan RunningTime { get; set; } // The error code for the failed operation. public string Code { get; set; } // The message for the failed operation. public string Message { get; set; } } /// <summary> /// Polls Get Operation Status for the operation specified by requestId /// every pollIntervalSeconds until timeoutSeconds have passed or the /// operation has returned a Failed or Succeeded status. /// </summary> /// <param name="requestId">The requestId of the operation to get status for.</param> /// <param name="pollIntervalSeconds">The interval between calls to Get Operation Status.</param> /// <param name="timeoutSeconds">The maximum number of seconds to poll.</param> /// <returns>An OperationResult structure with status or error information.</returns> private static OperationResult PollGetOperationStatus( string requestId, int pollIntervalSeconds, int timeoutSeconds) { OperationResult result = new OperationResult(); DateTime beginPollTime = DateTime.UtcNow; TimeSpan pollInterval = new TimeSpan(0, 0, pollIntervalSeconds); DateTime endPollTime = beginPollTime + new TimeSpan(0, 0, timeoutSeconds); bool done = false; while (!done) { XElement operation = GetOperationStatus(requestId); result.RunningTime = DateTime.UtcNow - beginPollTime; try { // Turn the Status string into an OperationStatus value result.Status = (OperationStatus)Enum.Parse( typeof(OperationStatus), operation.Element(wa + "Status").Value); } catch (Exception) { throw new ApplicationException(string.Format( "Get Operation Status {0} returned unexpected status: {1}{2}", requestId, Environment.NewLine, operation.ToString(SaveOptions.OmitDuplicateNamespaces))); } switch (result.Status) { case OperationStatus.InProgress: Console.WriteLine( "In progress for {0} seconds", (int)result.RunningTime.TotalSeconds); Thread.Sleep((int)pollInterval.TotalMilliseconds); break; case OperationStatus.Failed: result.StatusCode = (HttpStatusCode)Convert.ToInt32( operation.Element(wa + "HttpStatusCode").Value); XElement error = operation.Element(wa + "Error"); result.Code = error.Element(wa + "Code").Value; result.Message = error.Element(wa + "Message").Value; done = true; break; case OperationStatus.Succeeded: result.StatusCode = (HttpStatusCode)Convert.ToInt32( operation.Element(wa + "HttpStatusCode").Value); done = true; break; } if (!done && DateTime.UtcNow > endPollTime) { result.Status = OperationStatus.TimedOut; done = true; } } return result; } /// <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 GetStoreCertificate(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> /// A helper function to invoke a Service Management REST API operation. /// Throws an ApplicationException on unexpected status code results. /// </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="expectedCode">The expected status code.</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> /// <returns>The requestId returned by the operation.</returns> private static string InvokeRequest( Uri uri, string method, HttpStatusCode expectedCode, XDocument requestBody, out XDocument responseBody) { responseBody = null; string 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(); } 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 requestId; } } /// <summary> /// Helpful extension methods for converting strings to and from Base-64. /// </summary> public static class StringExtensions { /// <summary> /// Converts a UTF-8 string to a Base-64 version of the string. /// </summary> /// <param name="s">The string to convert to Base-64.</param> /// <returns>The Base-64 converted string.</returns> public static string ToBase64(this string s) { byte[] bytes = System.Text.Encoding.UTF8.GetBytes(s); return Convert.ToBase64String(bytes); } /// <summary> /// Converts a Base-64 encoded string to UTF-8. /// </summary> /// <param name="s">The string to convert from Base-64.</param> /// <returns>The converted UTF-8 string.</returns> public static string FromBase64(this string s) { byte[] bytes = Convert.FromBase64String(s); return System.Text.Encoding.UTF8.GetString(bytes); } } }
Dieses Beispielprogramm erzeugt bei der Ausführung eine Konsolenausgabe, die dem folgenden Beispiel ähnelt:
Called Create Storage Account operation: requestId 8ba8bd9cdc50472892a0b3cd3659b297 In progress for 0 seconds In progress for 20 seconds In progress for 41 seconds In progress for 61 seconds In progress for 82 seconds In progress for 103 seconds Succeeded: Operation 8ba8bd9cdc50472892a0b3cd3659b297 completed after 123 seconds with status 200 (OK) New Storage Account Properties for myexamplestorage1: <StorageService xmlns="https://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> <ServiceName>myexamplestorage1</ServiceName> <StorageServiceProperties> <Description>Description for my example storage account</Description> <Location>North Central US</Location> <Label>My example storage account label</Label> <Status>Created</Status> <Endpoints> <Endpoint>http://myexamplestorage1.blob.core.windows.net/</Endpoint> <Endpoint>http://myexamplestorage1.queue.core.windows.net/</Endpoint> <Endpoint>http://myexamplestorage1.table.core.windows.net/</Endpoint> </Endpoints> <GeoReplicationEnabled>true</GeoReplicationEnabled> <GeoPrimaryRegion>usnorth</GeoPrimaryRegion> <StatusOfPrimary>Available</StatusOfPrimary> <GeoSecondaryRegion>ussouth</GeoSecondaryRegion> <StatusOfSecondary>Available</StatusOfSecondary> </StorageServiceProperties> </StorageService> Press any key to continue: