Miten julkaista ja hallita Azure Functions -sovelluksia pilvessä

Azure Functions tarjoaa tehokkaan tavan rakentaa serverittömiä, skaalautuvia sovelluksia, jotka reagoivat eri laukaiseviin tapahtumiin, kuten HTTP-pyynnöihin, aikarajoitteisiin ja viestijonoihin. Tämä malli mahdollistaa kehittäjille mahdollisuuden keskittyä liiketoimintalogiikkaan ilman huolta infrastruktuurista tai palvelinten hallinnasta.

Kun Azure Functions -sovellus on valmis kehittämiselle ja testaamiselle, seuraava askel on sen julkaiseminen pilveen. Tätä prosessia varten on useita työkaluja, kuten Visual Studio ja Visual Studio Code, jotka tekevät julkaisuprosessista helpon ja suoraviivaisen. Tärkeää on kuitenkin muistaa, että kehittäessäsi Azure Functions -sovelluksia kannattaa huomioida eri julkaisutavat ja -asetukset, sillä ne vaikuttavat suoritettavan koodin käytettävyyteen ja toimintatehokkuuteen pilvessä.

Ennen julkaisua on tärkeää varmistaa, että sovelluksen kokoonpanotiedostot, kuten .NET-version asetus ja mahdolliset varoitukset, kuten "You are using a preview version of .NET", ovat kunnossa. Esimerkiksi Visual Studio -kehitysympäristössä voit valita julkaisukokoonpanon (Release) ja varmistaa, että koodin rakennusprosessissa ei ole virheitä. Julkaisun aikana voidaan nähdä ilmoituksia, kuten "Publish started", joka kertoo, että prosessi on käynnistynyt.

Kun sovellus on julkaistu, on myös tärkeää hallita Azure-ympäristön resursseja. Azure tarjoaa yksinkertaisia työkaluja resurssien hallintaan, mukaan lukien mahdollisuuden poistaa sovellukseen liittyvät resurssit, kuten säilytystilapalvelut ja app-palvelusuunnitelmat. Tämä voi olla erityisen hyödyllistä, jos sovellusta ei enää tarvita, ja halutaan estää lisäkustannusten syntyminen.

Tärkeä osa Azure Functionsin hallintaa on myös sen resurssien puhdistaminen julkaisun jälkeen. Tällöin kannattaa tarkistaa, että kaikki resursseihin liittyvät komponentit, kuten tallennustilat ja sovellussuunnitelmat, on poistettu, jotta ei synny tarpeettomia kustannuksia.

Lisäksi Azure Functions tarjoaa erilaisia vaihtoehtoja ja asetuksia, joiden avulla voit muokata toimintojen suorituskykyä ja reagoivuutta eri tilanteissa. Esimerkiksi voit määrittää ajastettuja tehtäviä tai määritellä riippuvuuksia eri palveluiden kanssa. Tärkeää on ymmärtää Azure Functionsin joustavuus ja laaja tuki eri laukaiseville tapahtumille, sillä tämä mahdollistaa monenlaisten serverittömien sovellusten rakentamisen.

Azure Functionsin käyttöön liittyy monia mahdollisuuksia, mutta myös tärkeitä asioita, jotka on huomioitava kehittäjälle. Yksi keskeisistä asioista on, että vaikka Azure tarjoaa loistavat työkalut ja ympäristön serverittömien sovellusten kehittämiseen, se vaatii hyvää ymmärrystä pilviteknologioiden hallinnasta, erityisesti resurssien hallinnasta ja kustannusoptimoinnista. On myös tärkeää tutustua .NET:n eri versioihin ja niiden yhteensopivuuteen Azure Functionsin kanssa.

Miten rakentaa ja käyttää Blazor WebAssembly -komponentteja palvelimella ja asiakaspuolella?

Blazor WebAssembly -sovelluksen kehittämisessä on otettava huomioon, että projektiin liittyvät tiedostot ja kansiot voivat olla monivaiheisia, mikä tekee polkuviitteiden hallinnasta hieman monimutkaisempaa. Esimerkiksi, jos käytetään yhteisiä projekteja, kuten entiteettimalleja ja tietokantaa, polkureferenssit voivat olla kolmen tason etäisyydellä, esimerkiksi "......", koska kansioita on lisätty Server-, Client- ja Shared-kohteiden käsittelyyn.

Ensimmäinen vaihe on kääntää Northwind.BlazorWasm.Server-projekti komennolla tai terminaalissa. Seuraavaksi ohjelmassa, erityisesti Program.cs-tiedostossa, on tärkeää tuoda oikeat nimialueet minimal-API-attribuuttien, tietokannan kontekstin rekisteröintimenetelmien ja JSON-sarjoittamisen käsittelemiseksi. Esimerkiksi seuraavat koodirivit ovat oleellisia:

csharp
Copy code
using Microsoft.AspNetCore.Mvc; // [FromServices]

using Packt.Shared; // AddNorthwindContext extension method
using System.Text.Json.Serialization; // ReferenceHandler
using HttpJsonOptions = Microsoft.AspNetCore.Http.Json.JsonOptions;

Ohjelman käynnistysvaiheessa, CreateBuilder-kutsun jälkeen, on määritettävä JSON-vaihtoehtojen säilyttämismenetelmä, joka estää pyöreiden viitteiden aiheuttamat virheet:

csharp
Copy code
builder.Services.Configure(options =>
{
    options.SerializerOptions.ReferenceHandler = ReferenceHandler.Preserve;
});

csharp
Copy code
builder.Services.AddNorthwindContext();

csharp
Copy code
app.MapGet("api/employees", ([FromServices] NorthwindContext db) => Results.Json(db.Employees))
    .WithName("GetEmployees")
    .Produces(StatusCodes.Status200OK);
app.MapPost("api/employees", async ([FromBody] Employee employee, [FromServices] NorthwindContext db) =>
{
    db.Employees.Add(employee);
    await db.SaveChangesAsync();
    return Results.Created($"api/employees/{employee.EmployeeId}", employee);
})
    .Produces(StatusCodes.Status201Created);

Kun API-päätepisteet on määritelty, seuraava vaihe on rakentaa asiakaspuolen komponentti, joka kutsuu palvelimen web-palvelua ja käsittelee saatuja tietoja. Tässä tapauksessa käytämme Blazor WebAssembly -asiakaspuolen komponenttia, jossa käytetään QuickGrid-komponenttia, joka on avoimen lähdekoodin työkalu tietojen esittämiseen taulukoina. QuickGrid toimii parhaiten, kun se on sidottu IQueryable-datanäkymään. Komponentin määrittely tapahtuu seuraavasti:

csharp
Copy code
@page "/employees/{country?}"

@inject IHttpClientFactory httpClientFactory

OnParametersSetAsync-metodissa haetaan kaikki työntekijät ja suodatetaan ne valitun maan mukaan:

csharp
Copy code
protected override async Task OnParametersSetAsync()
{
    Employee[]? employeesArray = null;
    JsonSerializerOptions jsonOptions = new()
    {
        ReferenceHandler = ReferenceHandler.Preserve,
        PropertyNameCaseInsensitive = true
    };
    HttpClient client = httpClientFactory.CreateClient("Northwind.BlazorWasm.ServerAPI");
    string path = "api/employees";
    try
    {
        employeesArray = await client.GetFromJsonAsync(path, jsonOptions);
    }
    catch (Exception ex)
    {
        Console.WriteLine($"{ex.GetType()}: {ex.Message}");
    }
    if (employeesArray is not null)
    {
        employees = employeesArray.AsQueryable();
        if (!string.IsNullOrWhiteSpace(Country))
        {
            employees = employees.Where(emp => emp.Country == Country);
        }
    }
}

Tämä lähestymistapa yhdistää Blazor WebAssembly -asiakas- ja palvelinpuolen komponentit saumattomasti ja mahdollistaa dynaamisen ja joustavan verkkosovelluksen rakentamisen.

Kuinka Blazor-sovelluksessa käytetään kontekstivalikkoja, ilmoituksia ja palveluja käyttäjän valintojen käsittelemiseksi

Blazor-sovelluksissa on mahdollista käsitellä käyttäjän interaktioita monin eri tavoin, erityisesti kontekstivalikoiden, ilmoitusten ja dialogien avulla. Tässä käsitellään, kuinka voit käyttää näitä komponentteja luodaksesi dynaamisia ja käyttäjäystävällisiä kokemuksia sovelluksessasi.

Esimerkiksi, jos käyttäjä valitsee toimitusyrityksen ilman Ctrl-näppäintä, voit näyttää yksinkertaisen ilmoituksen, jossa kerrotaan valinnan tiedot. Tämä voidaan toteuttaa NotificationService-komponentilla, joka hallitsee ilmoituksia sovelluksessa. Jos taas käyttäjä pitää Ctrl-näppäintä painettuna, voit avata vahvistusdialogin, jossa käyttäjä voi valita, haluaako hän jatkaa valinnan kanssa.

Seuraava esimerkki näyttää, kuinka voit toteuttaa tämän:

csharp
Copy code
async void OnMenuItemClick(MenuItemEventArgs args) 

{ 
    contextMenuService.Close(); 
    if (args.CtrlKey) 
    { 
        bool? clickedYes = await dialogService.Confirm( 
            message: $"Visitor selected: {args.Text}", 
            title: $"Value={args.Value}", 
            new ConfirmOptions() { OkButtonText = "Yes", CancelButtonText = "No" });
        string title = string.Format("You clicked \"{0}\"", 
            (clickedYes.GetValueOrDefault(true) ? "Yes" : "No")); 
        DialogOptions options = new() 
        { 
            CloseDialogOnOverlayClick = true, 
            CloseDialogOnEsc = true 
        }; 
        dialogService.Open(title, ds => 
            @$"<h1>{title}</h1>", options); 
    } 
    else 
    { 
        NotificationMessage message = new() 
        { 
            Severity = (NotificationSeverity)args.Value, 
            Summary = $"Value={args.Value}", 
            Detail = $"Visitor selected: {args.Text}", 
            Duration = 4000 
        }; 
        notificationService.Notify(message); 
    } 
}

Tässä koodissa tarkastellaan, onko Ctrl-näppäin painettu. Jos se on, avataan vahvistusdialogi. Jos ei, näytetään ilmoitus, joka sulkeutuu automaattisesti muutaman sekunnin kuluttua.

Tämäntyyppinen käyttäjäkokemus tekee sovelluksesta interaktiivisemman ja informatiivisemman. Käyttäjä ei jää epätietoisuuteen siitä, mitä hän on valinnut, ja sovellus reagoi valintaan visuaalisesti.

Seuraavaksi käsitellään Blazor-sovelluksen kehittämistä laajentamalla sitä API:ksi, joka voi noutaa tietoja tietokannasta, kuten Northwind-tietokannasta. Tämä mahdollistaa tietojen hakemisen ja näyttämisen käyttäjälle.

Kun luot web-palvelua, käytetään "Minimal API" -ratkaisua, jossa voit määrittää reitit ja hakea tietoja eri tauluista, kuten kategorioista ja tilauksista. Esimerkiksi:

csharp
Copy code
app.MapGet("api/categories", ([FromServices] NorthwindContext db) => 
    Results.Json(db.Categories.Include(c => c.Products))
    .WithName("GetCategories")
    .Produces(StatusCodes.Status200OK));
app.MapGet("api/orders/", ([FromServices] NorthwindContext db) => 
    Results.Json(db.Orders.Include(o => o.OrderDetails))
    .WithName("GetOrders")
    .Produces(StatusCodes.Status200OK));

Näiden reittien avulla voidaan helposti noutaa ja näyttää tietoja, kuten tuotekategorioita ja tilauksia, joita voidaan käyttää sovelluksen käyttöliittymässä.

Blazor-sovelluksissa on mahdollista käyttää myös monia muita komponentteja, kuten Radzenin kuvia ja kuvakkeita, jotka voivat parantaa visuaalista ilmettä. Kuvakkeet voivat liittyä tiettyihin kategorioihin ja tehdä navigoinnista sujuvampaa. Google Material Icons -kokoelma tarjoaa laajan valikoiman kuvakkeita, joita voidaan käyttää Blazor-sovelluksessa.

Kuinka asynkroninen ohjelmointi parantaa käyttöliittymän reagointikykyä?

Asynkroninen ohjelmointi on olennainen osa nykyaikaisia ohjelmointikäytäntöjä, erityisesti silloin, kun rakennetaan sovelluksia, joissa käyttöliittymä (UI) täytyy pysyä responsiivisena pitkien ja mahdollisesti estäviä operaatioita suorittavien taustatehtävien aikana. C#-kääntäjä luo monimutkaisen tilakoneen ja seuraa samanaikaisesti ajettavia säikeitä. Tämä on melkein maagista! Kaksi avainsanaa, kuten async ja await, yhdistettynä mahdollistavat sen, että asynkroninen metodi suoritetaan taustasäikeellä ja sen valmistuttua tulokset palautetaan käyttöliittymän säikeelle, pitäen näin sovelluksen reagointikyvyn.

Tarkastellaan esimerkkiä, jossa luodaan Windowsin työpöytäsovellus WPF:n avulla. Sovellus hakee työntekijöiden tietoja Northwind-tietokannasta, joka on SQL Serverin tietokanta. Tämä esimerkki näyttää, kuinka asynkroninen ja synkroninen koodin suoritus eroaa toisistaan käyttöliittymän responsiivisuuden kannalta.

Ensinnäkin, WPF-sovelluksessa luodaan käyttöliittymä, jossa on kaksi painiketta, tekstikenttä ja listaruutu. Kun käyttäjä klikkaa painikkeita, sovellus joko hakee tietoja synkronisesti tai asynkronisesti SQL Serveristä. Tässä on tärkeää huomata, että synkroninen lähestymistapa estää käyttöliittymän käytön, kun taas asynkroninen lähestymistapa mahdollistaa sen, että käyttöliittymä pysyy aktiivisena ja reagoi käyttäjän toimiin koko tietojen hakemisen ajan.

Synkronisessa koodissa, kuten seuraavassa esimerkissä, ohjelma odottaa tietokannan yhteyden avaamista ja tietojen hakemista ennen kuin se siirtyy seuraavaan vaiheeseen:

csharp
Copy code
private void GetEmployeesSyncButton_Click(object sender, RoutedEventArgs e)

{
    Stopwatch timer = Stopwatch.StartNew();
    using (SqlConnection connection = new(connectionString))
    {
        try
        {
            connection.Open();
            SqlCommand command = new(sql, connection);
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                string employee = string.Format("{0}: {1} {2}",
                    reader.GetInt32(0), reader.GetString(1), reader.GetString(2));
                EmployeesListBox.Items.Add(employee);
            }
            reader.Close();
            connection.Close();
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        }
    }
    EmployeesListBox.Items.Add($"Sync: {timer.ElapsedMilliseconds:N0}ms");
}

Tässä esimerkissä sovellus ei reagoi käyttäjän syötteisiin ennen kuin tietojen hakeminen on valmis, mikä tekee käyttöliittymästä hetkellisesti jähmeän ja vaikeasti käytettävän.

Asynkronisessa versiossa, kuten alla olevassa koodissa, async ja await -avainsanojen käyttö varmistaa sen, että tietojen haku tapahtuu taustalla eikä estä käyttöliittymän toimintoja:

csharp
Copy code
private async void GetEmployeesAsyncButton_Click(object sender, RoutedEventArgs e)
{
    Stopwatch timer = Stopwatch.StartNew();
    using (SqlConnection connection = new(connectionString))
    {
        try
        {
            await connection.OpenAsync();
            SqlCommand command = new(sql, connection);
            SqlDataReader reader = await command.ExecuteReaderAsync();
            while (await reader.ReadAsync())
            {
                string employee = string.Format("{0}: {1} {2}",
                    await reader.GetFieldValueAsync(0),
                    await reader.GetFieldValueAsync(1),
                    await reader.GetFieldValueAsync(2));
                EmployeesListBox.Items.Add(employee);
            }
            await reader.CloseAsync();
            await connection.CloseAsync();
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        }
    }
    EmployeesListBox.Items.Add($"Async: {timer.ElapsedMilliseconds:N0}ms");
}

Asynkronisuus ei kuitenkaan ole ilman haasteita. Esimerkiksi async-metodin määrittäminen void-tyypiksi ei ole suositeltavaa, koska se voi johtaa ongelmiin virheenkäsittelyssä ja peruutustoimintojen puutteessa. Tällöin ei ole mahdollista tietää, milloin operaatio on valmis, eikä sille voida määrittää peruuttamismekanismia.

Lopuksi on hyvä muistaa, että asynkroninen ohjelmointi on erityisen tärkeää verkkosovelluksille ja -palveluille. Asynkroniset operaatiot voivat parantaa palvelinten skaalautuvuutta, koska ne eivät estä palvelimen säikeiden käyttöä odotellessaan pitkiä I/O-operaatioita, kuten verkkopyyntöjä. Tämä tarkoittaa, että palvelin pystyy käsittelemään useampia pyyntöjä samanaikaisesti, mikä parantaa suorituskykyä ja vähentää viiveitä.

Miksi ja miten valita oikeat teknologiat ja arkkitehtuuriratkaisut tehokkuuden lisäämiseksi?

Teknologian ja arkkitehtuurin valinnalla on suuri merkitys ohjelmistokehityksessä. Ne eivät vain määrittele, kuinka ohjelmisto toimii, vaan myös sen, kuinka helposti sitä voidaan ylläpitää, skaalata ja kehittää edelleen. Oikeiden työkalujen valitseminen ja niiden tehokas hyödyntäminen voivat säästää valtavasti aikaa ja resursseja. Tämä luku käsittelee, miten valita ja implementoida oikeat teknologiat ja arkkitehtuuriratkaisut nopeasti ja tehokkaasti.

Jos olet valmis syventymään ohjelmointiin ja haluat nähdä konkreettisia esimerkkejä ja harjoituksia, voit ladata tai kloonata ratkaisuja GitHub-repositorysta, joka on tarjolla kirjan käyttöön. Linkki löytyy: https://github.com/markjprice/apps-services-net7. Jos et ole varma, miten tämä tehdään, saat ohjeet Chapter 1:ssa, jossa käydään läpi Visual Studio 2022:n ja Visual Studio Coden käyttöä ympäristön asennuksessa.

Tässä kirjassa käsitellään vaihe vaiheelta tärkeitä ohjelmointitehtäviä, joiden avulla lukija voi kehittää, testata ja optimoida ohjelmointiratkaisuja. Ensimmäisessä luvussa tutustutaan .NET-ympäristön perustamiseen Visual Studio 2022:ssa tai Visual Studio Codessa. Tavoitteena on opettaa lukijalle, miten hyödyntää C#:n ja .NETin uusimpia ominaisuuksia tehokkaasti ohjelmointityössä. Erityisesti tutustumme moderniin C#:n syntaksiin ja .NETin tarjoamiin kirjastoihin, jotka mahdollistavat ohjelmoinnin eri tasoilla.

Kolmannessa luvussa tarkastellaan NoSQL-tietokantoja ja erityisesti Azure Cosmos DB:tä. Tämä pilvipalvelu on suunniteltu erityisesti suurten tietomäärien hallintaan ja tarjoaa kehittäjille mahdollisuuden käyttää erilaisia rajapintoja, kuten Gremlin-rajapintaa. Tämän luvun avulla lukija oppii, kuinka käyttää Cosmos DB:tä tehokkaasti ja miten käsitellä suuria tietomassoja.

Kun puhutaan suoritustehosta, neljäs luku tutkii, kuinka hyödyntää samanaikaisuutta ja rinnakkaisuutta ohjelman suorituskyvyn parantamiseksi. Erityisesti luku käsittelee, miten hyödyntää System.Diagnostics-nimekkeen tyyppejä ja Benchmark.NET-kirjastoa suorituksen mittaamisessa ja optimoinnissa. Multitaskingin avulla voidaan luoda sovelluksia, jotka pystyvät käsittelemään useita tehtäviä samanaikaisesti, parantaen käyttäjäkokemusta ja sovelluksen skaalautuvuutta.

Kuudes luku keskittyy koodin suorittamisen tarkkailuun ja dynaamiseen muokkaamiseen. Tällöin käsitellään reflektiota, ilmaisepuita ja koodin luomista käännösprosessin aikana. Tämä on tärkeää, kun halutaan kehittää joustavia ja laajennettavissa olevia sovelluksia, jotka pystyvät mukautumaan erilaisiin tarpeisiin ja ympäristöihin.

Tietojen ja sovellusten suojaaminen on tärkeä osa ohjelmistokehitystä. Kahdeksas luku käsittelee salauksia, tiivisteitä ja allekirjoituksia tietojen suojaamiseksi. Lisäksi käydään läpi autentikointi ja autorisointi, jotka ovat tärkeitä tekijöitä, kun halutaan estää luvaton pääsy sovelluksiin.

OData-tekniikka, joka mahdollistaa datan nopean altistamisen useille HTTP-päätepisteille, esitellään kymmenennessä luvussa. Tämä luku auttaa lukijaa ymmärtämään, miksi OData on erinomainen valinta nopeaan ja tehokkaaseen datan altistamiseen eri asiakkaille ja palveluille.

Luku GraphQL:stä tutustuttaa lukijan siihen, kuinka yhdistää useita tietolähteitä yhdeksi rajapinnaksi. Tämä tekniikka on erityisen hyödyllinen, kun halutaan yhdistää monimutkaisia tietorakenteita ja tarjota yksinkertainen ja joustava rajapinta loppukäyttäjälle.

Lopuksi, kun tarkastellaan mikro-palveluarkkitehtuuria, luku gRPC:stä opastaa, kuinka luoda tehokkaita mikro-palveluja. gRPC tarjoaa erittäin suorituskykyisen tavan luoda palveluja, jotka pystyvät käsittelemään suuria tietomääriä nopeasti ja luotettavasti. Lisäksi luku SignalR:stä esittelee, kuinka luodaan reaaliaikaisia sovelluksia, jotka voivat lähettää tietoa useille asiakkaille yhtä aikaa.

Tärkeää on, että lukija ei pelkästään seuraa esimerkkejä, vaan ymmärtää valittujen teknologioiden taustat ja perusteet. Tämä mahdollistaa kyvyn valita oikeat työkalut kunkin projektin tarpeisiin ja takaa koodin joustavuuden ja ylläpidettävyyden tulevaisuudessa.