Staging- of productie-instantie?

Is er ergens in de service runtime dat me zou vertellen of ik momenteel op ‘Staging’ of ‘Production’ werk? Het handmatig wijzigen van de configuratie van en naar productie lijkt een beetje omslachtig.


Antwoord 1, autoriteit 100%

Je zou je configuraties eigenlijk niet moeten veranderen als je uitgaat van Prod of Staging. Staging-ruimte is niet ontworpen als een “QA”-omgeving, maar alleen als wachtruimte voordat de productie wordt geïmplementeerd.

Wanneer u een nieuwe implementatie uploadt, wordt het huidige implementatieslot waar u uw pakket naar uploadt vernietigd en is het gedurende 10-15 minuten niet beschikbaar terwijl het uploaden en starten van VM’s plaatsvindt. Als u rechtstreeks naar productie uploadt, is dat 15 minuten productieonderbreking. Zo werd Staging-gebied uitgevonden: je uploadt naar staging, test het spul en klikt op de knop “Swap” en je Staging-omgeving wordt op magische wijze Productie (virtuele IP-swap).
Je enscenering zou dus echt 100% hetzelfde moeten zijn als je productie.

Wat ik denk dat u zoekt, is een QA/testomgeving? U moet een nieuwe service voor de testomgeving openen met een eigen Prod/Staging. In dit geval wilt u meerdere sets configuratiebestanden onderhouden, één set per implementatieomgeving (productie, testen, enz.)

Er zijn veel manieren om de configuratie-hel te beheren die optreedt, vooral met Azure dat bovenop .config-bestanden zijn eigen *.cscfg-bestanden heeft. De manier waarop ik het het liefst doe met Azure-project is als volgt:
Stel een klein configuratieproject in, maak daar mappen aan die overeenkomen met implementatietypen. Binnen elke map set-up sets van *.config & *.cscfg-bestanden die overeenkomen met een bepaalde implementatieomgeving: Debug, Test, Release… deze worden ook in Visual Studio ingesteld als builddoeltypen. Ik heb een kleine xcopy-opdracht die optreedt tijdens elke compilatie van het Config-project die alle bestanden kopieert van de Build Target-map van het Config-project naar de hoofdmap van het Config-project.

Vervolgens LINKS elk ander project in de oplossing naar het .config- of .cscfg-bestand vanuit de hoofdmap van het Config-project.

Voila, mijn configuraties passen zich op magische wijze automatisch aan elke buildconfiguratie aan. Ik gebruik ook .config-transformaties om foutopsporingsinformatie te beheren voor release- versus niet-release-builddoelen.

Als je dit allemaal hebt gelezen en toch de Production vs. Staging-status tijdens runtimewilt bereiken, dan:
Haal deploymentIdop van RoleEnvironment.DeploymentId
Gebruik vervolgens Management API met een juist X509 certificateom bij de Azure structure of your Servicete komen en roep de methode GetDeploymentsaan (het is een rest-api maar er is is een abstractiebibliotheek).

Hopelijk helpt dit

Bewerken: blogbericht zoals gevraagd over het instellen van configuratiereeksen en schakelen tussen omgevingen @ http://blog.paraleap.com/blog/post/Managing-environments-in-a-distributed-Azure-or-other- cloudgebaseerde NET-oplossing


Antwoord 2, autoriteit 69%

Soms zou ik willen dat mensen de vraag gewoon zouden beantwoorden.. zonder ethiek of best practices uit te leggen…

Microsoft heeft hier een codevoorbeeld gepost dat precies dit doet: https://code.msdn .microsoft.com/windowsazure/CSAzureDeploymentSlot-1ce0e3b5

afbeelding met Staging-instantie

afbeelding met productie-instantie

protected void Page_Load(object sender, EventArgs e) 
{ 
    // You basic information of the Deployment of Azure application. 
    string deploymentId = RoleEnvironment.DeploymentId; 
    string subscriptionID = "<Your subscription ID>"; 
    string thrumbnail = "<Your certificate thumbnail print>"; 
    string hostedServiceName = "<Your hosted service name>"; 
    string productionString = string.Format(
        "https://management.core.windows.net/{0}/services/hostedservices/{1}/deploymentslots/{2}",
        subscriptionID, hostedServiceName, "Production"); 
    Uri requestUri = new Uri(productionString); 
    // Add client certificate. 
    X509Store store = new X509Store(StoreName.My, StoreLocation.LocalMachine); 
    store.Open(OpenFlags.OpenExistingOnly); 
    X509Certificate2Collection collection = store.Certificates.Find(
        X509FindType.FindByThumbprint, thrumbnail, false); 
    store.Close(); 
    if (collection.Count != 0) 
    { 
        X509Certificate2 certificate = collection[0]; 
        HttpWebRequest httpRequest = (HttpWebRequest)HttpWebRequest.Create(requestUri); 
        httpRequest.ClientCertificates.Add(certificate); 
        httpRequest.Headers.Add("x-ms-version", "2011-10-01"); 
        httpRequest.KeepAlive = false; 
        HttpWebResponse httpResponse = httpRequest.GetResponse() as HttpWebResponse;
        // Get response stream from Management API. 
        Stream stream = httpResponse.GetResponseStream(); 
        string result = string.Empty; 
        using (StreamReader reader = new StreamReader(stream)) 
        { 
            result = reader.ReadToEnd();
        } 
        if (result == null || result.Trim() == string.Empty) 
        {
            return;
        }
        XDocument document = XDocument.Parse(result); 
        string serverID = string.Empty; 
        var list = from item
                   in document.Descendants(XName.Get("PrivateID",
                       "http://schemas.microsoft.com/windowsazure")) 
                   select item; 
        serverID = list.First().Value; 
        Response.Write("Check Production: "); 
        Response.Write("DeploymentID : " + deploymentId
            + " ServerID :" + serverID); 
        if (deploymentId.Equals(serverID)) 
            lbStatus.Text = "Production"; 
        else 
        { 
            // If the application not in Production slot, try to check Staging slot. 
            string stagingString = string.Format(
                "https://management.core.windows.net/{0}/services/hostedservices/{1}/deploymentslots/{2}",
                subscriptionID, hostedServiceName, "Staging"); 
            Uri stagingUri = new Uri(stagingString); 
            httpRequest = (HttpWebRequest)HttpWebRequest.Create(stagingUri); 
            httpRequest.ClientCertificates.Add(certificate); 
            httpRequest.Headers.Add("x-ms-version", "2011-10-01"); 
            httpRequest.KeepAlive = false; 
            httpResponse = httpRequest.GetResponse() as HttpWebResponse; 
            stream = httpResponse.GetResponseStream(); 
            result = string.Empty; 
            using (StreamReader reader = new StreamReader(stream)) 
            { 
                result = reader.ReadToEnd();
            } 
            if (result == null || result.Trim() == string.Empty) 
            {
                return;
            }
            document = XDocument.Parse(result); 
            serverID = string.Empty; 
            list = from item
                   in document.Descendants(XName.Get("PrivateID",
                       "http://schemas.microsoft.com/windowsazure")) 
                   select item; 
            serverID = list.First().Value; 
            Response.Write(" Check Staging:"); 
            Response.Write(" DeploymentID : " + deploymentId
                + " ServerID :" + serverID); 
            if (deploymentId.Equals(serverID)) 
            {
                lbStatus.Text = "Staging";
            }
            else 
            {
                lbStatus.Text = "Do not find this id";
            }
        } 
        httpResponse.Close(); 
        stream.Close(); 
    } 
}

Antwoord 3, Autoriteit 10%

Staging is een tijdelijke implementatiesleuf die hoofdzakelijk wordt gebruikt voor de upgrades zonder downtime en het vermogen om een ​​upgrade terug te rollen.

Het wordt geadviseerd om uw systeem niet te koppelen (in de code of in de configuratie) met dergelijke Azure-specifieke kenmerken.


Antwoord 4, Autoriteit 8%

Sinds Windows Azure Management Librariesen dankzij @ GuaravMantri antwoordop een andere vraag, je kunt het als volgt doen:

using System;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using Microsoft.Azure;
using Microsoft.WindowsAzure.Management.Compute;
using Microsoft.WindowsAzure.Management.Compute.Models;
namespace Configuration
{
    public class DeploymentSlotTypeHelper
    {
        static string subscriptionId = "<subscription-id>";
        static string managementCertContents = "<Base64 Encoded Management Certificate String from Publish Setting File>";// copy-paste it
        static string cloudServiceName = "<your cloud service name>"; // lowercase
        static string ns = "http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceConfiguration";
        public DeploymentSlot GetSlotType()
        {
            var managementCertificate = new X509Certificate2(Convert.FromBase64String(managementCertContents));
            var credentials = new CertificateCloudCredentials(subscriptionId, managementCertificate);
            var computeManagementClient = new ComputeManagementClient(credentials);
            var response = computeManagementClient.HostedServices.GetDetailed(cloudServiceName);
            return response.Deployments.FirstOrDefault(d => d.DeploymentSlot == DeploymentSlot.Production) == null ? DeploymentSlot.Staging : DeploymentSlot.Production;
        }
    }
}

Antwoord 5, autoriteit 5%

Een gemakkelijke manier om dit probleem op te lossen, is door op uw instances een sleutel in te stellen om te identificeren in welke omgeving deze wordt uitgevoerd.

1) Stel in op uw productieslot:
Stel het in Instellingen >> Applicatie-instellingen >> App instellingen
En maak een sleutel met de naam SLOT_NAME en waarde ‘productie’. BELANGRIJK: controleer Slot instelling.

2) Stel in op uw staging-slot:
Stel het in Instellingen >> Applicatie-instellingen >> App instellingen
En maak een sleutel met de naam SLOT_NAME en waarde “staging”. BELANGRIJK: controleer Slot instelling.

Open vanuit uw toepassing de variabele en identificeer in welke omgeving de toepassing wordt uitgevoerd. In Java heb je toegang tot:

String slotName = System.getenv("APPSETTING_SLOT_NAME");

Antwoord 6

Hier zijn 4 punten om te overwegen

  1. VIP-swap heeft alleen zin als je service naar de buitenwereld is gericht. AKA, wanneer het een API blootlegt en reageert op verzoeken.
  2. Als uw service alleen maar berichten uit een wachtrij haalt en deze verwerkt, dan is uw service proactief en is VIP-swap geen goede oplossing voor u.
  3. Als je service zowel reactief als proactief is, wil je misschien je ontwerp heroverwegen. Splits de service misschien in 2 verschillende services.
  4. Eric’s suggestie om de cscfg-bestanden voor en na VIP-swap aan te passen is goed als het proactieve deel van uw service een korte downtime kan vergen (omdat u eerst zowel Staging als Production configureert om geen berichten op te halen, en vervolgens VIP Swap uitvoert , en werk vervolgens de configuratie van Production bij om berichten op te halen).

Other episodes