BLOGas.lt
Sukurk savo BLOGą Kitas atsitiktinis BLOGas

Windows Azure – 5 dalis

Parašė Sergejus | 2010-01-24 22:29

Praeitoje dalyje aš parodžiau, kaip pasinaudoti Windows Azure binarine BLOB saugykla failų talpinimui ir saugojimui. Šį kartą mes perkelsime prieš tai sukurtą aplikaciją į debesis.

BLOB saugyklos sukūrimas

Iki šiol BLOB saugyklos testavimui mes naudojome taip vadinamą „Development Storage“. Norėdami išpublikuoti mūsų Windows Azure aplikaciją į debesis, pirma reikia sukurti saugyklą Windows Azure portale. Įvedus norimą saugyklos pavadinimą bei adresą, jus pamatysite panašų vaizdą:

azure15

Iš paveiksliuko matyti, kad mano saugyklos pavadinimas yra Files, o nuoroda – http://sergejus.blob.core.windows.net. Taip pat žemiau pateikiami kodai, kurių pagalba galima prisijungti ir dirbti su saugykla iš aplikacijos.

Pakeitimai konfigūracijos faile

Turėdami egzistuojančią Windows Azure BLOB saugyklą, belieka nueiti į WindowsCloudWeb projekto konfigūracijos failą ir jame pakeisti prisijungimo eilutės StorageConnectionString reikšmę į prieš tai sukurtos saugyklos duomenis. Account name laukelyje reikia įvesti jūsų BLOB saugyklos nuorodos pradžią (viskas kas iki blob.core.windows.net, mano atveju – sergejus). Account key laukelyje įveskite Primary Access Key kodą:

azure16

Svarbu pažymėti, kad naujus BLOB saugyklos duomenis reikia nurodyti ne tik StorageConnectionString prisijungimo eilutėje, bet ir standartinėje DiagnosticsConnectionString prisijungimo eilutėje.

Tam kad patikrinti ar saugykla veikia, užtenka paleisti aplikaciją derinimui. Įsitikinus, kad viskas veikia kaip numatyta, galite išpublikuoti aplikaciją į Windows Azure kaip buvo aprašyta antroje dalyje.

Veikiantį programos pavyzdį galite rasti adresu http://hellocloud.cloudapp.net/Blob.aspx.

Kitoje dalyje…

Parodysiu kaip tą patį funkcionalumą galima pasiekti naudojant esybių lenteles (Tables) vietoje binarinės saugyklos (BLOB).

Rodyk draugams

Windows Azure – 4 dalis

Parašė Sergejus | 2010-01-20 00:19

Šioje dalyje mes panaudosime prieš tai sukonfigūruotą lokalią BLOB saugyklą. Kaip pavyzdį aš pateiksiu ASP.NET puslapį, kuriame galima pridėti naują failą į objektinę BLOB saugyklą, atvaizduoti esamus failus, juos parsisiųsti bei ištrinti. Po ilgų svarstymų, aš nusprendžiau apvilkti visas operacijas su Windows Azure į repozitorijaus (angl. repository) projektavimo šabloną.

BLOB pagrindai

BLOB saugykla – tai viena iš Windows Azure objektinių saugyklų, kuri yra skirta binarinių duomenų saugojimui. BLOB saugykla yra sudaryta iš konteinerių – katalogų analogo failų sistemoje. Būtent konteineriuose mes saugome BLOBus (duomenis). BLOBuose fiziškai saugomi ne tik duomenys, bet ir metaduomenys bei atitinkama unikali HTTP nuoroda (ID analogas).

BLOBus galima pasiekti dviem būdais: naudojant pastarąją nuorodą ir REST HTTP operacijas, arba specialų .NET API (jis toliau ir bus nagrinėjamas). Abiems atvejais vietoje ID naudojama nuoroda (Uri formatu).

„Hello World“ projekto pakeitimai

Už pagrindą aš pasiėmiau 2 dalyje aprašytą „Hello World“ Windows Azure ASP.NET aplikaciją. Kadangi darbui su objektinėmis saugyklomis mums reikės nurodyti Windows Azure prisijungimo duomenis, tam HelloWorldCloud projekte reikia nueiti į nustatymus ir pridėti naują prisijungimo eilutę, kurią aš pavadinau StorageConnectionString:

azure14

Atkreipkite dėmesį, kad laikinai mes naudojame ne realius Windows Azure prisijungimo duomenis, bet lokalią saugyklą. Kitas svarbus momentas – Web rolės klasės aprašymas. Kadangi Windows Azure BLOB saugykla nepriklauso nuo.NET vykdymo aplinkos (skaitykit nuo Microsoft.WindowsAzure.ServiceRuntime), reikia HelloWorldWeb projekte sukurti Web rolės klasę ir joje nusakyti kaip reaguoti į konfigūracijos failo pakeitimus. Žemiau pateiktas kodas yra nukopijuotas iš Windows Azure SDK, tikiuosi ateityje Microsoft sugalvos patogesnį sprendimą:

public class WebRole : RoleEntryPoint
{
    public override bool OnStart()
    {
        DiagnosticMonitor.Start("DiagnosticsConnectionString");

        // This code sets up a handler to update CloudStorageAccount instances when their corresponding
        // configuration settings change in the service configuration file.
        CloudStorageAccount.SetConfigurationSettingPublisher((settingName, configSetter) =>
        {
            // Provide the configSetter with the initial value
            configSetter(RoleEnvironment.GetConfigurationSettingValue(settingName));

            RoleEnvironment.Changed += (sender, arg) =>
            {
                if (arg.Changes.OfType<RoleEnvironmentConfigurationSettingChange>()
                    .Any(change => (change.ConfigurationSettingName == settingName)))
                {
                    // The corresponding configuration setting has changed, propagate the value
                    if (!configSetter(RoleEnvironment.GetConfigurationSettingValue(settingName)))
                    {
                        // In this case, the change to the storage account credentials in the
                        // service configuration is significant enough that the role needs to be
                        // recycled in order to use the latest settings. (for example, the 
                        // endpoint has changed)
                        RoleEnvironment.RequestRecycle();
                    }
                }
            };
        });

        // For information on handling configuration changes
        // see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
        RoleEnvironment.Changing += (sender, arg) =>
        {
            // If a configuration setting is changing
            if (arg.Changes.Any(change => change is RoleEnvironmentConfigurationSettingChange))
            {
                // Set e.Cancel to true to restart this role instance
                arg.Cancel = true;
            }
        };

        return base.OnStart();
    }
}

Puslapio sukūrimas

Kadangi puslapyje mes operuosime failais, apibrėžkime pagalbinę klasę FileMetaData, kurioje saugosime failo pavadinimą, turinio tipą bei failo nuorodą BLOBo saugykloje (turi būti unikali):

public class FileMetaData
{
    public Uri Uri { get; set; }
    public string FileName { get; set; }
    public string ContentType { get; set; }
}

Dabar apibrėšime repozitorijaus interfeisą su mums reikalingomis operacijomis:

public interface IFileRepository
{
    IEnumerable<FileMetaData> List();
    byte[] Get(Uri uri);
    void Insert(FileMetaData metaData, byte[] file);
    void Delete(Uri uri);
}

Aptarkime kiekvieno metodo paskirtį:

  • metodas List skirtas pateikti BLOB saugykloje saugomų failų sąrašą (be tų failų duomenų)
  • metodas Get gauna nurodyto failo duomenis
  • metodas Insert įterpia į BLOB saugyklą failą kartu su jo metaduomenimis
  • metodas Delete ištrina nurodytą failą iš BLOB saugyklos

Nesigilinant į IFileRepository realizaciją, pateiksiu Web puslapio kodą:

<%@ Page Language="C#" AutoEventWireup="true"
    CodeBehind="Default.aspx.cs" Inherits="HelloWorldWeb._Default" %>

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>Failų sąrašas</title>
</head>
<body>
    <form id="form" runat="server">
    <h1>Failai</h1>
    Pridėti naują
    <asp:FileUpload ID="FileUpload" runat="server" />
    <asp:Button runat="server" Text="Pridėti" OnClick="UploadFile" />
    <asp:ListView ID="Files" runat="server">
        <LayoutTemplate>
            <ul>
                <li id="itemPlaceHolder" runat="server" />
            </ul>
        </LayoutTemplate>
        <ItemTemplate>
            <li>
                <a href='<%# Eval("Uri") %>'> <%# Eval("FileName") %> </a>
                <asp:LinkButton runat="server" Text="[x]" OnCommand="DeleteFile"
                    CommandArgument='<%# Eval("Uri") %>' />
            </li>
        </ItemTemplate>
    </asp:ListView>
    </form>
</body>
</html>

Kaip matote, puslapyje tėra failo pridėjimo elementas bei sąrašas jau pridėtų failų su galimybe ištrinti. Failų pavadinimas yra atvaizduojamas kaip nuoroda, kad galima būtų jį parsisiųsti paprastu paspaudimu. C# pusė atrodo taip:

public partial class _Default : Page
{
    private readonly IFileRepository repository =
        new FileRepository("files", "StorageConnectionString");

    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            ListFiles();
        }
    }

    protected void UploadFile(object sender, EventArgs e)
    {
        if (FileUpload.HasFile)
        {
            var file = FileUpload.FileBytes;
            var metaData = new FileMetaData
                               {
                                   FileName = FileUpload.PostedFile.FileName,
                                   ContentType = FileUpload.PostedFile.ContentType
                               };

            repository.Insert(metaData, file);

            ListFiles();
        }
    }

    protected void DeleteFile(object sender, CommandEventArgs e)
    {
        repository.Delete(new Uri(e.CommandArgument.ToString()));

        ListFiles();
    }

    private void ListFiles()
    {
        Files.DataSource = repository.List();
        Files.DataBind();
    }
}

Repozitorijaus dėka, šis ASP.NET puslapis neturi jokio supratimo apie Windows Azure panaudojimą.

FileRepository įgyvendinimas

Žemiau pateiktą FileRepository realizaciją aš pabandžiau maksimaliai paaiškinti komentarų pagalba. Atskirai norėtųsi tik paminėti FileRepository konstruktorių: jis priima du argumentus – BLOB konteinerio pavadinimą (leistinos tik mažosios raidės bei skaičiai) ir prisijungimo prie BLOB saugyklos eilutės pavadinimą iš mūsų konfigūracijos failo.

public class FileRepository : IFileRepository
{
    private readonly CloudBlobContainer blobContainer;

    public FileRepository(string container, string connectionString)
    {
        // aprašome mūsų BLOB klientą
        var storageAccount = CloudStorageAccount.FromConfigurationSetting(connectionString);
        var blobClient = storageAccount.CreateCloudBlobClient();

        // nustatome viešą prieigą prie duomenų
        var permissions = new BlobContainerPermissions();
        permissions.PublicAccess = BlobContainerPublicAccessType.Container;

        // pagal nurodytą vardą gauname egzistuojantį konteinerį arba sukuriame naują
        blobContainer = blobClient.GetContainerReference(container);
        blobContainer.CreateIfNotExist();
        blobContainer.SetPermissions(permissions);
    }

    public IEnumerable<FileMetaData> List()
    {
        // gauname informaciją apie prieinamus BLOBus
        var blobItems = blobContainer.ListBlobs();
        var metaData = new List<FileMetaData>();

        foreach (var blobItem in blobItems)
        {
            // gauname nuorodą į BLOBą...
            var blob = blobContainer.GetBlobReference(blobItem.Uri.ToString());
            // ... ir jo meta duomenis
            blob.FetchAttributes();

            // sukuriame objektą atvaizdavimui
            metaData.Add(new FileMetaData
                             {
                                 Uri = blob.Uri,
                                 FileName = blob.Metadata["FileName"],
                                 ContentType = blob.Properties.ContentType
                             });
        }

        return metaData;
    }

    public byte[] Get(Uri uri)
    {
        // parsisiunčiame duomenis
        return blobContainer.GetBlockBlobReference(uri.ToString()).DownloadByteArray();
    }

    public void Insert(FileMetaData metaData, byte[] file)
    {
        // sukuriame naują BLOBą
        var blob = blobContainer.GetBlobReference(Guid.NewGuid().ToString());
        // siunčiame failo duomenis...
        blob.UploadByteArray(file);
        // ... bei nurodome meta duomenis
        blob.Metadata["FileName"] = metaData.FileName;
        blob.SetMetadata();
        blob.Properties.ContentType = metaData.ContentType;
        blob.SetProperties();
    }

    public void Delete(Uri uri)
    {
        // gauname nuorodą į BLOBą...
        var blob = blobContainer.GetBlobReference(uri.ToString());
        // ir bandome jį ištrinti
        blob.DeleteIfExists();
    }
}

Kitoje dalyje…

Parodysiu kaip panaudoti realią Windows Azure BLOB saugyklą.

Rodyk draugams

Įvadas į Windows Azure – 3 dalis

Parašė Sergejus | 2010-01-12 23:58

Kadangi kiti mano straipsniai naudos vienokią ar kitokią Windows Azure objektinę saugyklą, šioje trumpoje dalyje parodysiu kaip sukonfigūruoti lokalią objektinę saugyklą.

Konfigūravimas

Pirmoje dalyje aš užsimyniau, kad Windows Azure šiuo metu turi dviejų tipų objektines saugyklas: binarines (BLOB) ir esybių lenteles (tables). Prie saugyklų yra priskiriamos ir eilės (queues), kurių pagalba galima asinchroniškai keistis duomenis tarp rolių. Džiugi žinia, kad kuriant debesų aplikacijas mes galime naudotis ne tik visomis standartinėmis Visual Studio galimybėmis (įskaitant derinimą), bet ir lokaliame kompiuteryje emuliuoja Windows Azure aplinka (Development Fabric ir Development Storage). Paskutinė yra emuliuojama SQL Server pagalba ir reikalauja atskiro konfigūravimo.

Windows Azure objektinė saugykla konfigūruojama DSInit.exe programos pagalba (iš katalogo C:\Program Files\Windows Azure SDK\v1.0\bin\devstore):

DSInit.exe /sqlinstance:. /forceCreate

Parametras sqlinstance nurodo SQL duomenų bazės serverio pavadinimą („taškas“ reiškia localhost), o parametras forceCreate sukuria naują objektinę saugyklą net jeigu tokia egzistuoja:

azure11

Tam kad iš aplikacijos pasinaudoti lokalia objektine saugykla, Windows Azure projekto nustatymuose konfigūracijos parametrui Start Development Storage Services reikia nurodyti reikšmę true:

azure12

Derinimo metu bus emuliuojami net tik serveriai, bet ir saugykla:

azure13

Atkreipkite dėmesį į tai, kad visos saugyklos yra pasiekiamos per HTTP, bet apie tai kitose dalyse…

Kitoje dalyje…

Pereisime prie darbo su esybių lentelėmis.

Rodyk draugams

Naujas .NET tinklaraštis lietuvių kalba

Parašė Sergejus | 2010-01-11 21:53

Mano geras draugas, Lietuvos .NET vartotojų grupės narys, o dabar ir Microsoft Lietuva Developer Evangelist - Tautvydas Dagys, pradėjo rašyti tinklaraštį .NET Pasaulis. Tikiuosi šio reikalo jis neapleis ir ateityje mus nudžiugins puikiais straipsniais. O kol kas įsidėmėkite dar vieną lietuvišką tinklaraštį apie .NET - http://blogs.msdn.com/tdagys.

Rodyk draugams

Įvadas į Windows Azure – 2 dalis

Parašė Sergejus | 2010-01-08 00:55

Šioje dalyje aš aprašysiu kaip sukurti paprasčiausią Windows Azure „Hello World“ puslapį ir patalpinti jį į debesis.

Įrankiai

Prieš pradedant, mums reikės Visual Studio 2008 su SP1, Windows Azure SDK ir Windows Azure Tools for Microsoft Visual Studio. Šiame straipsnių cikle aš specialiai naudoju Visual Studio 2008, o ne 2010, kad kuo daugiau norinčių galėtų išbandyti Windows Azure platformą „gyvai“ jau dabar.

Puslapio sukūrimas

Pradėsime nuo to, kad sukursime paprastą ASP.NET puslapį Default.aspx, kuris atrodys taip:

<%@ Page Language="C#" AutoEventWireup="true"
    CodeBehind="Default.aspx.cs" Inherits="HelloWorldWeb._Default" %>

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>Hello World</title>
</head>
<body>
    <form id="form" runat="server">
   
    Linkėjimai iš debesų! 
   
    </form>
</body>
</html>

Turėdami egzistuojantį Web projektą, mes galime pradėti jo perkėlimą į debesis. Tam sukurkime naują Windows Azure Cloud Service tipo projektą:

azure3 

Kaip matyti, šiuo metu egzistuoja vienintelis projekto šablonas. Pasirinkus jį, atsiras kitas langas, kuriame galima nurodyti kokius papildomus projektus reikia sukurti:

azure4

Kadangi mes norime perkelti egzistuojančią ASP.NET Web aplikaciją, tai šiame lange nieko nesirenkame ir tiesiog spaudžiame OK. Naujai atsiradusiame projekte, spaudžiame dešiniu pelės mygtuku ant katalogo Roles, pasirenkame Web Role Project in Solution ir pažymime mūsų Web aplikaciją.

azure5

Kartu su Windows Azure SDK instaliuojama ir visa virtuali Windows Azure platformos aplinka: Fabric, serveriai, saugyklos. Paskutinės yra emuliuojamos naudojant paprasčiausią SQL Express ir reikalauja atskiro konfigūravimo (apie tai kitose dalyse). Šiam pavyzdžiui mums saugykla nėra reikalinga, todėl debesų projekto nustatymuose ją atjungsime:

azure6

Kaip jau ne kartą buvo sakyta, viena svarbiausių Windows Azure savybių – galimybė labai paprastai keisti reikalingų rolių (serverių) skaičių. Įdomumo dėlei padidinkime Web rolių kiekį iki 2. Tai darome mūsų Web rolės nustatymuose (kataloge Roles spaudžiame du kartus ant mūsų Web rolės):

azure7

Jeigu dabar paleisime debesų projektą derinimui, pastebėsite, kad pasileido ne tik Web aplikacija, bet Windows įrankių juostos šone pasileido Development Fabric:

azure8

Tai yra ypač geras būdas pamatyti kaip mūsų Web rolės dirbs realioje aplinkoje.

Diegimas debesyse

Turėdami veikiančią ASP.NET Web aplikaciją skirtą Windows Azure, mums belieka ją sudiegti į debesis. Tam dešiniu pelės mygtuku spaudžiame ant debesų projekto ir pasirenkame Publish. Svarbu: prieš publikuodami puslapį atkeiskite Web rolių skaičių į 1, nes tik tiek galima nemokamai kurti su Demo kodu). Rezultate bus sugeneruoti du failai kaip parodyta žemiau: *.cscfg yra konfigūracijos failas, o *.cspkg – ZIP archyvas su mūsų Web aplikacija ir visomis priklausomybėmis.

azure9 

Po to kai failai yra sugeneruoti, naršyklėje automatiškai atsidaro Windows Azure puslapis, kuriame pasirinkite egzistuojantį (arba sukurkite naują) Windows Azure servisą ir paspauskite Upgrade:

azure10

Atsidariusiame lange jums tereikia nurodyti kelius iki prieš tai sugeneruotų *.cscfg ir *.cspkg failų bei suteikti žymę šiam diegimui. Už apytiksliai 10 minučių turėsite veikiančią Web rolę kartu su „Hello World“ Web aplikacija!

Kitoje dalyje…

Sukonfigūruosime SQL Express skirtą Windows Azure saugyklos emuliacijai.

Rodyk draugams

Įvadas į Windows Azure – 1 dalis

Parašė Sergejus | 2010-01-05 00:12

Šioje dalyje aš padarysiu trumpą įvadą į Windows Azure, paaiškinsiu svarbiausias sąvokas bei aprašysiu pagrindinius komponentus. Prieš tęsiant, rekomenduoju jums susipažinti su debesų kompiuterija bendrai.

Windows Azure – tai Microsoft debesų kompiuterijos variantas, kuris šiuo metu yra priskiriamas prie Platform-as-a-Service (toliau PaaS) paslaugų tipo, bet anot Microsoft greitu metu bus siūlomos ir Infrastructure-as-a-Service (toliau IaaS) tipo paslaugos. Šiuo metu Windows Azure platformą sudaro:

azure1

Windows Azure

Windows Azure galima įsivaizduoti kaip virtualių Windows serverių rinkinį, kuris yra valdomas, stebimas bei esant gėdimui automatiškai atstatomas specialios programinės įrangos, kuri vadinama Fabric (nepainioti su Windows Azure platform AppFabric).

Visi virtualūs serveriai yra pasiekiami naudojant apkrovos paskirstytoją (angl. Load Balancer), taip užtikrinant, kad visa apkrova bus tolygiai paskirstyta tarp visų vienos rolės serverių. Šiuo metu egzistuoja dvi serverių rolės: Web rolė ir Worker rolė. Pirmą galima įsivaizduoti kaip Web serverį, o antrą – kaip aplikacijų serverį. Svarbu pažymėti, kad jūsų programa nebūtinai turi naudoti abi roles, galima, pavyzdžiui, naudoti tik Web rolę. Aplikacijos naudojamų rolių skaičius irgi gali skirtis, pavyzdžiui, dvi Web rolės ir viena Worker rolė, viskas priklauso tik nuo poreikio. Pagrindinė Worker rolės paskirtis – užtikrinti ypač gerą atliekamų operacijų plečiamumą (angl. Scalability) naudojant asinchroninį apsikeitimą žinutėmis paremtą eilėmis. Asinchroninį komunikavimą ir eiles detaliau aprašysiu ateinančiuose straipsniuose.

Paskutinė svarbi Windows Azure dalis – objektinės saugyklos. Šiuo metu jos yra dvi: BLOBai ir lentelės (aš vadinsiu esybių lentelėmis). BLOB (Binary Large Object) – tai bendro pobūdžio binarinė saugykla, skirta bet kokio tipo informacijai saugoti. BLOBą galima įsivaizduoti kaip konteinerį, į kuri mes galime saugoti failus. Šiuo metu BLOBą galima pasiekti per unikalią HTTP nuorodą arba naudojant GUIDą. Artimiausiu metu atsiras galimybė prijungti jį prie Windows Azure serverio failų sistemos ir matyti iš aplikacijų kaip paprastą diską. Esybių lentelės pagal paskirtį yra panašios į SQL lenteles (tik nenaudojamos norminės formos). Kiekviena esybių lentelė savyje saugo esybes, kiekviena esybė yra sudaryta iš savybių, kiekviena savybė saugo informaciją apie jos pavadinimą, tipą bei saugomą reikšmę. Visos esybių lentelės yra pasiekiamos ADO.NET Data Services ir LINQ pagalba (per HTTP protokolą).

Windows Azure yra paremtas Windows Server 2008 x64 su IIS 7 ir palaiko:

  • .NET 3.5 SP1
  • Java
  • Ruby (Ruby on Rails)
  • PHP
  • C, Assembler
  • MySQL, SQLite

Windows Azure virtualius serverius galima plėsti tiek į plotį (pridedant naujus serverius), tiek į aukštį (pasirenkant galingesnę konfigūraciją). Šiuo metu yra siūlomos 4 galimos konfigūracijos:

VM CPU RAM HDD
Small 1 x 1.7 GHz 1.7 GB 250 GB
Medium 2 x 1.7 GHz 3.5 GB 500 GB
Large 4 x 1.7 GHz 7 GB 1000 GB
Extra Large 8 x 1.7 GHz 15 GB 2000 GB

 

SQL Azure

SQL Azure tai yra specialiai debesims adaptuota SQL Server versija, kuri palaiko pagrindines SQL Server ir T-SQL galimybes. Ateityje žadama, kad šis skirtumas pakankamai greitai mažės. SQL Azure įgyvendina TDS protokolą, todėl įmanoma naudotis tokiais įrankiais kaip Bulk Copy, SQL Management Studio, pasiekti SQL Azure iš Visual Studio, jungtis iš esamų aplikacijų vien pakeitus prisijungimo eilutę konfigūracijos faile.

Vienas didžiausių SQL Azure apribojimų šiuo metu yra duomenų bazių didžiai: 10 GB arba 1 GB. Norint išlaikyti gerą plečiamumą esant didesniam duomenų kiekiui, teks pasinaudoti duomenų bazių horizontalaus plečiamumo technika – sharding. Laimei, jau šių metų pabaigoje Microsoft žada gerokai padidinti maksimalų duomenų bazės dydį.

Kartu su SQL Azure yra prieinamas Microsoft Sync Framework praplėtimas, skirtas sinchronizacijai tarp SQL Azure ir SQL Server – SQL Azure Data Sync.

Windows Azure platform AppFabric

Windows Azure platform AppFabric, anksčiau žinomas kaip Azure .NET Services, yra aktyviai plėtojama Windows Azure platformos dalis. AppFabric sudaro: Service Bus ir Access Control komponentai. Service Bus leidžia apjungti programas, duomenų bazes ir servisus, esančius skirtinguose tinkluose ar debesyse. Jų autentifikacija yra naudojamas Access Control. Šiuo metu autentifikacijai galima naudoti Active Directory Federation Services (ADFS) bei atvirus protokolus Web Resource Authorization Protocol (WRAP) ir Simple Web Token (SWT).

Kitoje dalyje…

Pereisime prie kodo ir sukursime mūsų pirmą Windows Azure “Hello World” Web aplikaciją.

Rodyk draugams