내보내기(0) 인쇄
모두 확장

서비스 인증서 삭제

업데이트 날짜: 2014년 4월

Delete Service Certificate 작업은 호스팅 서비스의 인증서 저장소에서 서비스 인증서를 삭제합니다.

Delete Service Certificate 작업은 비동기 작업입니다. 관리 서비스가 요청 처리를 완료했는지 확인하려면 작업 상태 가져오기를 호출합니다. 비동기 작업에 대한 자세한 내용은 비동기 서비스 관리 요청 추적을 참조하십시오.

다음과 같이 Delete Service Certificate 요청을 지정할 수 있습니다. <subscription-id>를 구독 ID로 바꾸고, <service-name>을 호스팅 서비스의 DNS 접두사 이름으로 바꾸고, <thumbprint-algorithm>을 서비스 인증서 지문의 알고리즘으로 바꾸고, <thumbprint-in-hexadecimal>을 지문의 16진수 표현으로 바꾸십시오.

 

메서드 요청 URI HTTP 버전

DELETE

https://management.core.windows.net/<subscription-id>/services/hostedservices/<service-name>/certificates/<thumbprint-algorithm>-<thumbprint_in_hexadecimal>

HTTP/1.1

다음 표에서는 필수 요청 헤더와 선택적 요청 헤더에 대해 설명합니다.

 

요청 헤더 설명

x-ms-version

필수 사항입니다. 이 요청에 사용할 작업의 버전을 지정합니다. 이 헤더는 2009-10-01 이후 버전으로 설정되어야 합니다. 버전 헤더에 대한 자세한 내용은 서비스 관리 버전 관리를 참조하십시오.

응답에는 HTTP 상태 코드 및 응답 헤더 집합이 포함되어 있습니다.

Delete Service Certificate은 비동기 작업이므로 작업 상태 가져오기를 호출하여 작업이 완료되었는지, 실패했는지, 계속 진행 중인지 여부를 확인해야 합니다.

Delete Service Certificate은 비동기 작업이므로 항상 상태 코드 202(수락)를 반환합니다. 작업이 완료된 후 작업의 상태 코드를 확인하려면 작업 상태 가져오기를 호출합니다. 이 작업의 응답에 상태 코드가 포함됩니다. 성공한 경우의 상태 코드는 200(정상)입니다.

상태 코드에 대한 자세한 내용은 서비스 관리 상태 및 오류 코드를 참조하십시오.

이 작업의 응답에는 다음과 같은 헤더가 포함됩니다. 응답에는 추가 표준 HTTP 헤더가 포함될 수도 있습니다. 모든 표준 헤더는 HTTP/1.1 프로토콜 사양을 따릅니다.

 

응답 헤더 설명

x-ms-request-id

관리 서비스에 대해 수행된 요청을 고유하게 식별하는 값입니다. 비동기 작업의 경우 이 헤더 값과 함께 작업 상태 가져오기를 호출하여 작업이 완료되었는지, 실패했는지, 계속 진행 중인지 여부를 확인할 수 있습니다. 자세한 내용은 비동기 서비스 관리 요청 추적을 참조하십시오.

<subscription-id>로 지정된 구독에 연결된 관리 인증서를 사용하여 이 작업을 인증할 수 있습니다. 자세한 내용은 서비스 관리 요청 인증을 참조하십시오.

Delete Service Certificate 작업을 사용하면 특정 호스팅 서비스와 연결된 인증서를 프로그래밍 방식으로 삭제할 수 있습니다. 작업 결과는 요청 ID와 함께 즉시 반환되지만 삭제는 Windows Azure에서 비동기적으로 수행됩니다. 인증서 삭제 작업이 완료된 시간을 확인하려면 요청 ID와 함께 작업 상태 가져오기 작업을 폴링하면 됩니다. 그러면 Status 요소가 포함된 Operation 요소와 함께 XML 본문이 반환됩니다. 삭제 작업의 상태에 따라 이 값은 InProgress, Failed 또는 Succeeded입니다. 상태가 Failed 또는 Succeeded가 될 때까지 폴링하면 Operation 요소의 StatusCode 요소에 상태 코드가 포함됩니다. 작업이 실패한 경우 Error 요소에 추가 오류 정보가 포함됩니다. 자세한 내용은 작업 상태 가져오기을 참조하십시오.

다음 예제에서는 지정된 호스팅 서비스에 pfx 인증서를 추가한 다음 호스팅 서비스에서 인증서를 삭제하는 콘솔 프로그램을 보여 줍니다. 예제를 실행하려면 서비스 인증서를 만든 후 인증서 개인 키를 pfx 파일로 Documents 폴더에 저장합니다. pfx 파일로 서비스 인증서를 만들 때 암호를 제공합니다. 이 암호는 나중에 호스팅 서비스에 인증서를 추가할 때 입력하게 됩니다. Version 문자열을 x-ms-version 헤더에서 사용할 값으로 업데이트하여 코드를 수정합니다. ManagementThumbprint 값을 관리 인증서 지문으로 설정합니다. SubscriptionId 값을 구독 ID로 설정하고 ServiceName을 호스팅 서비스의 DNS 접두사 이름으로 설정합니다. PfxFile 값을 서비스 인증서 pfx 파일의 이름으로 설정하고 CertificateThumbprint 값을 인증서 지문으로 설정합니다. 프로그램을 실행하면 프로그램에서 서비스 인증서 pfx 파일의 암호를 요청합니다. 그런 다음 서비스 인증서 추가 작업을 사용하여 호스팅 서비스에 인증서를 추가하고 작업 상태 가져오기 작업을 사용하여 비동기 결과를 폴링합니다. 결과가 제공되면 프로그램은 서비스 인증서 나열 작업을 사용하여 호스팅 서비스의 인증서를 표시합니다. 그 다음에는 Delete Certificate 작업을 사용하여 추가한 인증서를 호스팅 서비스에서 제거하고 작업 상태 가져오기 작업을 사용하여 비동기 결과를 폴링합니다. 마지막으로 이 프로그램은 서비스 인증서 나열 작업을 사용하여 인증서가 제거되었음을 보여 줍니다. 인증서를 만들고, .pfx 파일로 내보내고, 인증서 지문을 구하는 방법에 대한 자세한 내용은 Windows Azure용 서비스 인증서 만들기을 참조하십시오.

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 XMsVersion = "2011-10-01";
        private const string ManagementThumbprint = "management-certificate-thumbprint";
        private const string SubscriptionId = "subscription-identifier";
        private const string ServiceName = "service-dns-prefix-name";
        private const string PfxFile = "service-certificate-pfx-file";
        private const string CertificateThumbprint = "service-certificate-thumbprint";
 
        // This is the common namespace for all Service Management REST API XML data.
        private static XNamespace wa = "http://schemas.microsoft.com/windowsazure";
 
        /// <summary>
        /// The operation status values from PollGetOperationStatus.
        /// </summary>
        private enum OperationStatus
        {
            InProgress,
            Failed,
            Succeeded,
            TimedOut
        }
 
        /// <summary>
        /// Gets or sets the management certificate for subscription access.
        /// </summary>
        private static X509Certificate2 ManagementCertificate { get; set; }
 
        static void Main(string[] args)
        {
            try
            {
                ManagementCertificate = GetStoreCertificate(ManagementThumbprint);
 
                // Add a certificate from a particular PFX file in the users
                // documents folder:
                string certificatePath = Path.Combine(
                    Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
                    PfxFile);
                string certificateData = Convert.ToBase64String(
                    File.ReadAllBytes(certificatePath));
 
                Console.Write("Enter the password for {0}: ", PfxFile);
                string pfxPassword = Console.ReadLine();
 
                string requestId = AddCertificate(
                    ServiceName,
                    certificateData,
                    pfxPassword);
                Console.WriteLine(
                    "Called Add Certificate operation: requestId {0}",
                    requestId);
 
                // Loop on Get Operation Status for result of add certificate
                OperationResult result = PollGetOperationStatus(
                    requestId,
                    pollIntervalSeconds: 20,
                    timeoutSeconds: 180);
                DisplayOperationResult(requestId, result);
 
                // Display the certificates for the hosted service.
                XElement certificates = ListCertificates(ServiceName);
                Console.WriteLine(
                    "Certificates for Hosted Service {0}:{1}{2}",
                    ServiceName,
                    Environment.NewLine,
                    certificates.ToString(SaveOptions.OmitDuplicateNamespaces));
                
                // Now delete the added certificate
                requestId = DeleteCertificate(
                    ServiceName,
                    "sha1",
                    CertificateThumbprint);
                Console.WriteLine(
                    "Called Delete Certificate operation: requestId {0}",
                    requestId);
 
                // Loop on Get Operation Status for result of delete certificate
                result = PollGetOperationStatus(
                    requestId,
                    pollIntervalSeconds: 20,
                    timeoutSeconds: 180);
                DisplayOperationResult(requestId, result);
 
                // Display the certificates for the hosted service.
                certificates = ListCertificates(ServiceName);
                Console.WriteLine(
                    "Certificates for Hosted Service {0}:{1}{2}",
                    ServiceName,
                    Environment.NewLine,
                    certificates.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();
        }
 
        private static void DisplayOperationResult(
            string requestId, 
            OperationResult result)
        {
            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;
            }
        }
 
        /// <summary>
        /// Calls the asynchronous Add Certificate operation in the Service 
        /// Management REST API to add a certificate to a hosted service. 
        /// Use the returned request ID value with the Get Operation Status 
        /// operation to get the final result of this operation.
        /// </summary>
        /// <param name="serviceName">The DNS prefix name of the hosted service to add the certificate to.</param>
        /// <param name="certificateData">The base-64 encoded contents of the .PFX file containing the certificate data.</param>
        /// <param name="password">The password to access the .PFX certificate data.</param>
        /// <returns>The request ID for use with Get Operation Status.</returns>
        private static string AddCertificate(
            string serviceName,
            string certificateData,
            string password)
        {
            string uriFormat = "https://management.core.windows.net/{0}" +
                "/services/hostedservices/{1}/certificates";
            Uri uri = new Uri(String.Format(uriFormat, SubscriptionId, serviceName));
 
            // Create the request XML document
            XDocument requestBody = new XDocument(
                new XDeclaration("1.0", "UTF-8", "no"),
                new XElement(
                    wa + "CertificateFile",
                    new XElement(wa + "Data", certificateData),
                    new XElement(wa + "CertificateFormat", "pfx"),
                    new XElement(wa + "Password", password)));
 
            XDocument responseBody;
            return InvokeRequest(
                uri, "POST", HttpStatusCode.Accepted, requestBody, out responseBody);
        }
 
        /// <summary>
        /// Calls the asynchronous Delete Certificate operation in the Service 
        /// Management REST API to remove a certificate from a hosted service. 
        /// Use the returned request ID value with the Get Operation Status 
        /// operation to get the final result of this operation.
        /// </summary>
        /// <param name="serviceName">The DNS prefix name of the hosted service to remove the certificate from.</param>
        /// <param name="algorithm">The algorithm of the certificate to delete, for example, "sha1".</param>
        /// <param name="thumbprint">The thumbprint for the certificate to delete.</param>
        /// <returns>The request ID for use with Get Operation Status.</returns>
        private static string DeleteCertificate(
            string serviceName,
            string algorithm,
            string thumbprint)
        {
            string uriFormat = "https://management.core.windows.net/{0}" +
                    "/services/hostedservices/{1}/certificates/{2}-{3}";
            Uri uri = new Uri(String.Format(
                uriFormat, SubscriptionId, serviceName, algorithm, thumbprint));
 
            XDocument responseBody;
            return InvokeRequest(
                uri, "DELETE", HttpStatusCode.Accepted, null, out responseBody);
        }
 
        /// <summary>
        /// Calls the List Certificates operation in the Service Management 
        /// REST API for the specified subscription and hosted service, and 
        /// returns the Certificates XML element from the response.
        /// </summary>
        /// <param name="serviceName">The DNS prefix name of the hosted service to list certificates for.</param>
        /// <returns>The HostedServices XML element from the response.</returns>
        private static XElement ListCertificates(
            string serviceName)
        {
            string uriFormat = "https://management.core.windows.net/{0}" +
                "/services/hostedservices/{1}/certificates";
            Uri uri = new Uri(String.Format(uriFormat, SubscriptionId, serviceName));
            XDocument responseBody;
            InvokeRequest(uri, "GET", HttpStatusCode.OK, null, out responseBody);
            return responseBody.Element(wa + "Certificates");
        }
 
        /// <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 e)
                {
                    throw new ApplicationException(string.Format(
                        "Get Operation Status {0} returned unexpected status: {1}{2}",
                        requestId,
                        Environment.NewLine,
                        operation.ToString(SaveOptions.OmitDuplicateNamespaces)),
                        e);
                }
 
                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", XMsVersion);
            request.ClientCertificates.Add(ManagementCertificate);
            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;
        }
    }
}

다음 출력 예제에서는 호스팅 서비스에 추가된 인증서를 보여 준 다음, 인증서가 삭제된 후 호스팅 서비스에 인증서가 없음을 보여 줍니다.

Enter the password for hostedservicecertificate.pfx: ********
Called Add Certificate operation: requestId fdcf42761fb1424688a5968aa38811d7
In progress for 0 seconds
Succeeded: Operation fdcf42761fb1424688a5968aa38811d7 completed after 21 seconds with status 200 (OK)
Certificates for Hosted Service MyHostedService1:
<Certificates xmlns="http://schemas.microsoft.com/windowsazure" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
  <Certificate>
    <CertificateUrl>https://management.core.windows.net/01234567-89ab-cdef-0123-456789abcdef/services/hostedservices/MyHostedService1/certificates/sha1-2EA90CBB65EFCF71C92F55363954A16B87941ECD</CertificateUrl>
    <Thumbprint>2EA90CBB65EFCF71C92F55363954A16B87941ECD</Thumbprint>
    <ThumbprintAlgorithm>sha1</ThumbprintAlgorithm>
    <Data>MIIDIDCCAgygAwIBAgIQFacJqSCsGKVGE19GKlrEejAJBgUrDgMCHQUAMCMxITAfBgNVBAMTGGhvc3RlZHNlcnZpY2VjZXJ0aWZpY2F0ZTAeFw0xMTExMTAwMDM3NDRaFw0zOTEyMzEyMzU5NTlaMCMxITAfBgNVBAMTGGhvc3RlZHNlcnZpY2VjZXJ0aWZpY2F0ZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAM94zedfRaAcpOESoStDBM/r18qdOI7HFawK+8sd+atW93L+pJgUjmEYgbHsBET2YZRTWHV2l6HkV7CRnSgTMQ/0SrIsGj+l1BG5Xncdp5Do9dbpHOQmZYVB3t3l0BcFgj3DP+atNXWctUpjdyDJB+USZJB7o0gz3esmyxdD1HaFBu1LW7GfhWHDmC0+QERdoKxAvVKY1wuvCxY1/LdCno6ZMV95l5xJ5jzf/itRo0A9wD5tlcR7bJL7Xp45REKZoaVwxCIooL8fC427LQf2EZbwjhU3kqPOyQ40vNTB+ksJneXqXjhh7Hefond9fFe6O7mwGVfbqOsbFWJsrTA7b40CAwEAAaNYMFYwVAYDVR0BBE0wS4AQMezArIE9mdwqywnNC9Y/NaElMCMxITAfBgNVBAMTGGhvc3RlZHNlcnZpY2VjZXJ0aWZpY2F0ZYIQFacJqSCsGKVGE19GKlrEejAJBgUrDgMCHQUAA4IBAQA0XehZ43Yt/u/NlOSYOkGhCeomndZbBcijGH9fo39OiMPwN1BOY1Ch1YmlTt60o/1u1Lg7oxx9+NfE4O2x2xqBK+SIT/W4gtowjmwFg+dRu0qRCYcJL1HaQWGoRbkZrJHNOKsBVUWJbSKyOtM/MZ2v5eZ2q2imDLNMnIPY6YaeP9s4lLhcu53iuzkHf1JvsmNkvI7XQkCw2W/COu8ndcXmTrhc1btz+j3r6G9siGeRQ+xDV394GIAtTZgszefJXVkjiYlHczUmr0ZPKWh3vA/RTyrcQfDVH0QBZ9CMYNhhI1PIJOPAQ3X5YsYQwah9pbYV4mIXaJKld+eNsEFt3Zo8</Data>
  </Certificate>
</Certificates>
Called Delete Certificate operation: requestId e480c3ffab2a4b7a840730200f004130
Succeeded: Operation e480c3ffab2a4b7a840730200f004130 completed after 0 seconds with status 200 (OK)
Certificates for Hosted Service MyHostedService1:
<Certificates xmlns="http://schemas.microsoft.com/windowsazure" xmlns:i="http://www.w3.org/2001/XMLSchema-instance" />
Press any key to continue:

표시:
© 2014 Microsoft