Oktatóanyag: Ef Migrations használata egy ASP.NET MVC-alkalmazásban, és üzembe helyezés az Azure-ban

A Contoso Egyetem minta webalkalmazása eddig helyileg futott az IIS Expressben a fejlesztői számítógépen. Ahhoz, hogy egy valós alkalmazást elérhetővé tegyen mások számára az interneten keresztül, üzembe kell helyeznie egy webszolgáltatónál. Ebben az oktatóanyagban engedélyezi a Code First migrálását, és üzembe helyezi az alkalmazást a felhőben az Azure-ban:

Kód első áttelepítésének engedélyezése. A Migrálások funkcióval módosíthatja az adatmodellt, és üzembe helyezheti a módosításokat az éles környezetben az adatbázisséma frissítésével anélkül, hogy le kellene dobnia és újra létre kellene hoznia az adatbázist.
Üzembe helyezés az Azure-ban. Ez a lépés nem kötelező; A többi oktatóanyagot anélkül folytathatja, hogy üzembe helyezte volna a projektet.

Javasoljuk, hogy az üzembe helyezéshez használjon folyamatos integrációs folyamatot a forrásvezérléssel, de ez az oktatóanyag nem fedi le ezeket a témaköröket. További információ: Felhőalapú natív .NET-mikroszolgáltatás automatikus üzembe helyezése a GitHub Actions és az Azure Pipelineshasználatával.

Ebben az oktatóanyagban ön:

Kód első migrálásának engedélyezése
Az alkalmazás üzembe helyezése az Azure-ban (nem kötelező)

Előfeltételek

Kapcsolati rugalmasság és parancs elfogása

Kód első migrálásának engedélyezése

Amikor új alkalmazást fejleszt, az adatmodell gyakran változik, és minden alkalommal, amikor a modell megváltozik, a rendszer nem szinkronizálódik az adatbázissal. Úgy konfigurálta az Entity Frameworkt, hogy minden egyes adatmodell módosításakor automatikusan eldobja és újra létrehozza az adatbázist. Ha entitásosztályokat ad hozzá, távolít el vagy módosít, vagy módosítja a DbContext osztályt, az alkalmazás következő futtatásakor automatikusan törli a meglévő adatbázist, létrehoz egy újat, amely megfelel a modellnek, és tesztadatokkal bővíti azt.

Ez a módszer, amellyel az adatbázis szinkronban marad az adatmodellel, mindaddig működik, amíg éles környezetben nem helyezi üzembe az alkalmazást. Amikor az alkalmazás éles környezetben fut, általában azokat az adatokat tárolja, amelyeket meg szeretne őrizni, és nem szeretne mindent elveszíteni minden módosításkor, például új oszlop hozzáadásakor. A Code First Migrations funkció úgy oldja meg ezt a problémát, hogy engedélyezi a Code First számára az adatbázisséma frissítését az adatbázis elvetése és újbóli létrehozása helyett. Ebben az oktatóanyagban üzembe helyezzük az alkalmazást, és erre felkészülve engedélyezzük a migrációkat.

Tiltsa le a korábban beállított inicializálót az alkalmazáshoz Web.config fájlhoz hozzáadott contexts elem megjegyzésével vagy törlésével.

<entityFramework>
  <!--<contexts>
    <context type="ContosoUniversity.DAL.SchoolContext, ContosoUniversity">
      <databaseInitializer type="ContosoUniversity.DAL.SchoolInitializer, ContosoUniversity" />
    </context>
  </contexts>-->
  <defaultConnectionFactory type="System.Data.Entity.Infrastructure.LocalDbConnectionFactory, EntityFramework">
    <parameters>
      <parameter value="v11.0" />
    </parameters>
  </defaultConnectionFactory>
  <providers>
    <provider invariantName="System.Data.SqlClient" type="System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer" />
  </providers>
</entityFramework>

Az alkalmazás Web.config fájlban is módosítsa a kapcsolati sztringben lévő adatbázis nevét ContosoUniversity2-re.
```
<connectionStrings>
  <add name="SchoolContext" connectionString="Data Source=(LocalDb)\MSSQLLocalDB;Initial Catalog=ContosoUniversity2;Integrated Security=SSPI;" providerName="System.Data.SqlClient" />
</connectionStrings>
```
Ez a módosítás úgy állítja be a projektet, hogy az első migrálás új adatbázist hoz létre. Ez nem kötelező, de később látni fogja, miért jó ötlet.
Az Eszközök menüben válassza a NuGet csomagkezelő>Csomagkezelő Konzollehetőséget.
A PM> parancssorban adja meg a következő parancsokat:
```
enable-migrations
add-migration InitialCreate
```
A enable-migrations parancs létrehoz egy Migrálások mappát a ContosoUniversity projektben, és a mappába helyez egy Configuration.cs fájlt, amelyet a migrálások konfigurálásához szerkeszthet.

(Ha elmulasztotta a fenti lépést, amely az adatbázis nevének módosítására utasítja, az áttelepítések megkeresik a meglévő adatbázist, és automatikusan elvégzik a add-migration parancsot. Ez rendben van, csak azt jelenti, hogy az adatbázis üzembe helyezése előtt nem fogja futtatni a migrálási kód tesztelését. Később, amikor futtatja a update-database parancsot, semmi sem fog történni, mert az adatbázis már létezik.)

Nyissa meg a ContosoUniversity\Migrations\Configuration.cs fájlt. A korábban látott inicializáló osztályhoz hasonlóan a Configuration osztály is tartalmaz egy Seed metódust.
```
internal sealed class Configuration : DbMigrationsConfiguration<ContosoUniversity.DAL.SchoolContext>
{
    public Configuration()
    {
        AutomaticMigrationsEnabled = false;
    }

    protected override void Seed(ContosoUniversity.DAL.SchoolContext context)
    {
        //  This method will be called after migrating to the latest version.

        //  You can use the DbSet<T>.AddOrUpdate() helper extension method 
        //  to avoid creating duplicate seed data. E.g.
        //
        //    context.People.AddOrUpdate(
        //      p => p.FullName,
        //      new Person { FullName = "Andrew Peters" },
        //      new Person { FullName = "Brice Lambson" },
        //      new Person { FullName = "Rowan Miller" }
        //    );
        //
    }
}
```
A "Seed" metódus célja, hogy lehetővé teszi a tesztadatok beszúrását vagy frissítését, miután a "Code First" létrehozza vagy frissíti az adatbázist. A metódust az adatbázis létrehozásakor és minden alkalommal meghívják, amikor az adatbázisséma frissül az adatmodell módosítása után.

A Seed metódus beállítása

Amikor minden adatmodell-módosításhoz elveti és újra létrehozza az adatbázist, az inicializáló osztály Seed metódusával szúrja be a tesztadatokat, mivel minden modellváltás után az adatbázis el lesz vetve, és az összes tesztadat elveszik. A Code First Migrations esetében a tesztadatok az adatbázis módosítása után megmaradnak, így a tesztelési adatok a Seed metódusba való belevétele általában nem szükséges. Valójában nem szeretné, hogy a Seed metódus tesztadatokat szúrjon be, ha migrálással telepíti az adatbázist éles környezetben, mert a Seed metódus éles környezetben fog futni. Ebben az esetben azt szeretné, hogy a Seed metódus csak az éles környezetben szükséges adatokat szúrja be az adatbázisba. Előfordulhat például, hogy azt szeretné, hogy az adatbázis tényleges részlegneveket tartalmazzon a Department táblában, amikor az alkalmazás éles környezetben elérhetővé válik.

Ebben az oktatóanyagban a Migrálásokat fogja használni az üzembe helyezéshez, de a Seed metódus mindenképpen beszúrja a tesztadatokat, hogy könnyebben láthassa az alkalmazás funkcióit anélkül, hogy manuálisan kellene sok adatot beszúrnia.

Cserélje le a Configuration.cs fájl tartalmát a következő kódra, amely betölti a tesztadatokat az új adatbázisba.

namespace ContosoUniversity.Migrations
{
    using ContosoUniversity.Models;
    using System;
    using System.Collections.Generic;
    using System.Data.Entity;
    using System.Data.Entity.Migrations;
    using System.Linq;

    internal sealed class Configuration : DbMigrationsConfiguration<ContosoUniversity.DAL.SchoolContext>
    {
        public Configuration()
        {
            AutomaticMigrationsEnabled = false;
        }

        protected override void Seed(ContosoUniversity.DAL.SchoolContext context)
        {
            var students = new List<Student>
            {
                new Student { FirstMidName = "Carson",   LastName = "Alexander", 
                    EnrollmentDate = DateTime.Parse("2010-09-01") },
                new Student { FirstMidName = "Meredith", LastName = "Alonso",    
                    EnrollmentDate = DateTime.Parse("2012-09-01") },
                new Student { FirstMidName = "Arturo",   LastName = "Anand",     
                    EnrollmentDate = DateTime.Parse("2013-09-01") },
                new Student { FirstMidName = "Gytis",    LastName = "Barzdukas", 
                    EnrollmentDate = DateTime.Parse("2012-09-01") },
                new Student { FirstMidName = "Yan",      LastName = "Li",        
                    EnrollmentDate = DateTime.Parse("2012-09-01") },
                new Student { FirstMidName = "Peggy",    LastName = "Justice",   
                    EnrollmentDate = DateTime.Parse("2011-09-01") },
                new Student { FirstMidName = "Laura",    LastName = "Norman",    
                    EnrollmentDate = DateTime.Parse("2013-09-01") },
                new Student { FirstMidName = "Nino",     LastName = "Olivetto",  
                    EnrollmentDate = DateTime.Parse("2005-08-11") }
            };
            students.ForEach(s => context.Students.AddOrUpdate(p => p.LastName, s));
            context.SaveChanges();

            var courses = new List<Course>
            {
                new Course {CourseID = 1050, Title = "Chemistry",      Credits = 3, },
                new Course {CourseID = 4022, Title = "Microeconomics", Credits = 3, },
                new Course {CourseID = 4041, Title = "Macroeconomics", Credits = 3, },
                new Course {CourseID = 1045, Title = "Calculus",       Credits = 4, },
                new Course {CourseID = 3141, Title = "Trigonometry",   Credits = 4, },
                new Course {CourseID = 2021, Title = "Composition",    Credits = 3, },
                new Course {CourseID = 2042, Title = "Literature",     Credits = 4, }
            };
            courses.ForEach(s => context.Courses.AddOrUpdate(p => p.Title, s));
            context.SaveChanges();

            var enrollments = new List<Enrollment>
            {
                new Enrollment { 
                    StudentID = students.Single(s => s.LastName == "Alexander").ID, 
                    CourseID = courses.Single(c => c.Title == "Chemistry" ).CourseID, 
                    Grade = Grade.A 
                },
                 new Enrollment { 
                    StudentID = students.Single(s => s.LastName == "Alexander").ID,
                    CourseID = courses.Single(c => c.Title == "Microeconomics" ).CourseID, 
                    Grade = Grade.C 
                 },                            
                 new Enrollment { 
                    StudentID = students.Single(s => s.LastName == "Alexander").ID,
                    CourseID = courses.Single(c => c.Title == "Macroeconomics" ).CourseID, 
                    Grade = Grade.B
                 },
                 new Enrollment { 
                     StudentID = students.Single(s => s.LastName == "Alonso").ID,
                    CourseID = courses.Single(c => c.Title == "Calculus" ).CourseID, 
                    Grade = Grade.B 
                 },
                 new Enrollment { 
                     StudentID = students.Single(s => s.LastName == "Alonso").ID,
                    CourseID = courses.Single(c => c.Title == "Trigonometry" ).CourseID, 
                    Grade = Grade.B 
                 },
                 new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Alonso").ID,
                    CourseID = courses.Single(c => c.Title == "Composition" ).CourseID, 
                    Grade = Grade.B 
                 },
                 new Enrollment { 
                    StudentID = students.Single(s => s.LastName == "Anand").ID,
                    CourseID = courses.Single(c => c.Title == "Chemistry" ).CourseID
                 },
                 new Enrollment { 
                    StudentID = students.Single(s => s.LastName == "Anand").ID,
                    CourseID = courses.Single(c => c.Title == "Microeconomics").CourseID,
                    Grade = Grade.B         
                 },
                new Enrollment { 
                    StudentID = students.Single(s => s.LastName == "Barzdukas").ID,
                    CourseID = courses.Single(c => c.Title == "Chemistry").CourseID,
                    Grade = Grade.B         
                 },
                 new Enrollment { 
                    StudentID = students.Single(s => s.LastName == "Li").ID,
                    CourseID = courses.Single(c => c.Title == "Composition").CourseID,
                    Grade = Grade.B         
                 },
                 new Enrollment { 
                    StudentID = students.Single(s => s.LastName == "Justice").ID,
                    CourseID = courses.Single(c => c.Title == "Literature").CourseID,
                    Grade = Grade.B         
                 }
            };

            foreach (Enrollment e in enrollments)
            {
                var enrollmentInDataBase = context.Enrollments.Where(
                    s =>
                         s.Student.ID == e.StudentID &&
                         s.Course.CourseID == e.CourseID).SingleOrDefault();
                if (enrollmentInDataBase == null)
                {
                    context.Enrollments.Add(e);
                }
            }
            context.SaveChanges();
        }
    }
}

A Seed metódus bemeneti paraméterként veszi fel az adatbázis környezeti objektumát, és a metódus kódja az objektum használatával új entitásokat ad hozzá az adatbázishoz. A kód minden entitástípushoz létrehoz egy új entitásgyűjteményt, hozzáadja őket a megfelelő DbSet tulajdonsághoz, majd menti az adatbázis módosításait. Nem szükséges meghívni a SaveChanges metódust az entitások minden egyes csoportja után, ahogy az itt látható, de ez segít megtalálni a probléma forrását, ha kivétel történik, miközben a kód az adatbázisba ír.

Az adatokat beszúró utasítások némelyike az AddOrUpdate metódust használja az "upsert" művelet végrehajtásához. Mivel a Seed metódus minden alkalommal fut, amikor végrehajtja a update-database parancsot, általában minden áttelepítés után, nem szúrhat be egyszerűen adatokat, mert a hozzáadni kívánt sorok már ott lesznek az adatbázist létrehozó első migrálás után. Az "upsert" művelet megakadályozza azokat a hibákat, amelyek akkor fordulnak elő, ha olyan sort próbál beszúrni, amely már létezik, de felülbírálja az alkalmazás tesztelése során esetleg végrehajtott összes adatmódosítást. Egyes táblák tesztadataival előfordulhat, hogy nem szeretné, hogy ez megtörténjen: bizonyos esetekben, amikor a tesztelés során módosítja az adatokat, azt szeretné, hogy a módosítások az adatbázis frissítése után is megmaradjanak. Ebben az esetben feltételes beszúrási műveletet szeretne végrehajtani: csak akkor szúrjon be egy sort, ha még nem létezik. A Seed metódus mindkét módszert alkalmazza.

Az AddOrUpdate metódusnak átadott első paraméter határozza meg azt a tulajdonságot, amelyet annak ellenőrzésére használ, hogy létezik-e már sor. Az Ön által megadott teszttanuló adataihoz a LastName tulajdonság használható erre a célra, mivel a lista minden vezetékneve egyedi:

context.Students.AddOrUpdate(p => p.LastName, s)

Ez a kód feltételezi, hogy a vezetéknevek egyediek. Ha manuálisan ad hozzá egy ismétlődő vezetéknevet tartalmazó tanulót, a következő kivételt fogja kapni a migrálás következő végrehajtásakor:

Sorozat több elemet tartalmaz

A redundáns adatok kezeléséről, például két, "Alexander Carson" nevű tanuló esetén, további információkat találhat Rick Anderson blogján található Seeding és hibakeresés az Entity Framework (EF) adatbázisokban című bejegyzésben. Julie Lerman blogján a „Vigyázz az EF 4.3 AddOrUpdate metódussal” című bejegyzésben talál további információt a AddOrUpdate metódusról.

Az Enrollment entitásokat létrehozó kód feltételezi, hogy a students gyűjtemény entitásaiban a ID érték szerepel, bár ezt a tulajdonságot nem a gyűjteményt létrehozó kódban állította be.

new Enrollment { 
    StudentID = students.Single(s => s.LastName == "Alexander").ID, 
    CourseID = courses.Single(c => c.Title == "Chemistry" ).CourseID, 
    Grade = Grade.A 
},

Itt használhatja a ID tulajdonságot, mert a ID érték a students gyűjtemény SaveChanges hívásakor van beállítva. Az EF automatikusan lekéri az elsődleges kulcs értékét, amikor beszúr egy entitást az adatbázisba, és frissíti az entitás ID tulajdonságát a memóriában.

Az egyes Enrollment entitásokat a Enrollments entitáskészlethez hozzáadó kód nem használja a AddOrUpdate metódust. Ellenőrzi, hogy egy entitás már létezik-e, és beszúrja az entitást, ha nem létezik. Ez a megközelítés megőrzi az alkalmazás felhasználói felületének használatával végzett módosításokat a felvételi osztályzaton. A kód végigfut a EnrollmentLista minden egyes tagján, és ha a regisztráció nem található az adatbázisban, hozzáadja a regisztrációt az adatbázishoz. Az adatbázis első frissítésekor az adatbázis üres lesz, ezért minden regisztrációt hozzáad.

foreach (Enrollment e in enrollments)
{
    var enrollmentInDataBase = context.Enrollments.Where(
        s => s.Student.ID == e.Student.ID &&
             s.Course.CourseID == e.Course.CourseID).SingleOrDefault();
    if (enrollmentInDataBase == null)
    {
        context.Enrollments.Add(e);
    }
}

Hozza létre a projektet.

Az első migrálás végrehajtása

Amikor végrehajtotta a add-migration parancsot, a migrálások létrehozták az adatbázist létrehozó kódot. Ez a kód szintén a Áttelepítések mappában található, a <időbélyeg>_InitialCreate.csnevű fájlban. A InitialCreate osztály Up metódusa létrehozza az adatmodell-entitáskészleteknek megfelelő adatbázistáblákat, és a Down metódus törli őket.

public partial class InitialCreate : DbMigration
{
    public override void Up()
    {
        CreateTable(
            "dbo.Course",
            c => new
                {
                    CourseID = c.Int(nullable: false),
                    Title = c.String(),
                    Credits = c.Int(nullable: false),
                })
            .PrimaryKey(t => t.CourseID);
        
        CreateTable(
            "dbo.Enrollment",
            c => new
                {
                    EnrollmentID = c.Int(nullable: false, identity: true),
                    CourseID = c.Int(nullable: false),
                    StudentID = c.Int(nullable: false),
                    Grade = c.Int(),
                })
            .PrimaryKey(t => t.EnrollmentID)
            .ForeignKey("dbo.Course", t => t.CourseID, cascadeDelete: true)
            .ForeignKey("dbo.Student", t => t.StudentID, cascadeDelete: true)
            .Index(t => t.CourseID)
            .Index(t => t.StudentID);
        
        CreateTable(
            "dbo.Student",
            c => new
                {
                    ID = c.Int(nullable: false, identity: true),
                    LastName = c.String(),
                    FirstMidName = c.String(),
                    EnrollmentDate = c.DateTime(nullable: false),
                })
            .PrimaryKey(t => t.ID);
        
    }
    
    public override void Down()
    {
        DropForeignKey("dbo.Enrollment", "StudentID", "dbo.Student");
        DropForeignKey("dbo.Enrollment", "CourseID", "dbo.Course");
        DropIndex("dbo.Enrollment", new[] { "StudentID" });
        DropIndex("dbo.Enrollment", new[] { "CourseID" });
        DropTable("dbo.Student");
        DropTable("dbo.Enrollment");
        DropTable("dbo.Course");
    }
}

A migrációs folyamatok meghívják az Up metódust az áttelepítés adatmodell-módosításainak implementálásához. Amikor megad egy parancsot a frissítés visszaállításához, a migrálás meghívja a Down metódust.

Ez az a kezdeti migrálás, amely a add-migration InitialCreate parancs megadásakor jött létre. A paraméter (InitialCreate a példában) a fájlnévhez használatos, és tetszőleges lehet; Általában olyan szót vagy kifejezést választ, amely összefoglalja a migrálás során végzett munkát. Elnevezhet például egy későbbi migrációt "AddDepartmentTable"-nek.

Ha a kezdeti áttelepítést akkor hozta létre, amikor az adatbázis már létezik, a rendszer létrehozza az adatbázis-létrehozási kódot, de nem kell futtatnia, mert az adatbázis már megfelel az adatmodellnek. Amikor egy másik olyan környezetben helyezi üzembe az alkalmazást, ahol az adatbázis még nem létezik, ez a kód az adatbázis létrehozásához fog futni, ezért érdemes először tesztelni. Ezért módosította korábban az adatbázis nevét a kapcsolati sztringben, hogy az áttelepítések újat hozzanak létre az alapoktól.

A Package Manager konzol ablakban adja meg a következő parancsot:

update-database

A update-database parancs a Up metódust futtatja az adatbázis létrehozásához, majd a Seed metódust futtatja az adatbázis feltöltéséhez. Ugyanez a folyamat az alkalmazás üzembe helyezése után automatikusan éles környezetben fog futni, ahogy az a következő szakaszban látható.
A Server Explorer használatával vizsgálja meg az adatbázist, ahogyan az első oktatóanyagban tette, és futtassa az alkalmazást annak ellenőrzéséhez, hogy minden továbbra is ugyanúgy működik-e, mint korábban.

Üzembe helyezés az Azure-ban

Az alkalmazás eddig helyileg futott az IIS Expressben a fejlesztői számítógépen. Ahhoz, hogy mások számára elérhetővé tegye az interneten keresztül, üzembe kell helyeznie egy webszolgáltatónál. Az oktatóanyag ezen szakaszában üzembe fogja helyezni az Azure-ban. Ez a szakasz nem kötelező; ezt kihagyhatja, és folytathatja a következő oktatóanyagot, vagy módosíthatja az ebben a szakaszban található utasításokat egy másik, ön által választott szolgáltatóhoz.

Az adatbázis üzembe helyezése a Code First migrálással

Az adatbázis üzembe helyezéséhez a Code First Migrationst kell használnia. Amikor létrehozza a Visual Studióból való üzembe helyezési beállítások konfigurálásához használt közzétételi profilt, bejelöli a Adatbázis frissítésefeliratú jelölőnégyzetet. Ez a beállítás azt eredményezi, hogy az üzembe helyezési folyamat automatikusan konfigurálja az alkalmazás Web.config fájlt a célkiszolgálón, hogy a Code First a MigrateDatabaseToLatestVersion inicializáló osztályt használja.

A Visual Studio nem végez semmit az adatbázissal az üzembe helyezési folyamat során, miközben a projektet a célkiszolgálóra másolja. Amikor futtatja az üzembe helyezett alkalmazást, és az első alkalommal fér hozzá az adatbázishoz az üzembe helyezés után, a Code First ellenőrzi, hogy az adatbázis megfelel-e az adatmodellnek. Ha eltérés van, a Code First automatikusan létrehozza az adatbázist (ha még nem létezik), vagy frissíti az adatbázis sémáját a legújabb verzióra (ha létezik adatbázis, de nem felel meg a modellnek). Ha az alkalmazás migrálási Seed metódust implementál, a metódus az adatbázis létrehozása vagy a séma frissítése után fut.

A "Your Migrations" Seed metódus tesztadatokat szúr be. Ha éles környezetben helyezne üzembe, módosítania kell a Seed metódust, hogy az csak azokat az adatokat szúrja be, amelyeket be szeretne szúrni az éles adatbázisba. Az aktuális adatmodellben például érdemes lehet valós kurzusokat végezni, de fiktív diákokat a fejlesztési adatbázisban. Megírhat egy Seed metódust a fejlesztési és éles környezetbe történő betöltésre, majd megjegyzésbe teheti a fiktív diákokat, mielőtt üzembe helyezi a termelési környezetbe. Vagy írhat egy Seed metódust, amely csak kurzusokat tölt be, és manuálisan írja be a fiktív diákokat a tesztadatbázisba az alkalmazás felhasználói felületének használatával.

Azure-fiók lekérése

Azure-fiókra lesz szüksége. Ha még nem rendelkezik ilyen előfizetéssel, de rendelkezik Visual Studio-előfizetéssel, aktiválhatja az előfizetés előnyeit. Ellenkező esetben néhány perc alatt létrehozhat egy ingyenes próbaverziós fiókot. További részletekért lásd Ingyenes Azure-próbaverziós.

Webhely és SQL-adatbázis létrehozása az Azure-ban

Az Azure-beli webalkalmazás megosztott üzemeltetési környezetben fog futni, ami azt jelenti, hogy más Azure-ügyfelekkel megosztott virtuális gépeken (virtuális gépeken) fut. A megosztott üzemeltetési környezetek alacsony költséggel járnak a felhőben való első lépésekhez. Később, ha a webes forgalom növekszik, az alkalmazás méretezhető, hogy megfeleljen az igényeknek dedikált virtuális gépeken való futtatásával. Ha többet szeretne megtudni az Azure App Service díjszabási beállításairól, olvassa el App Service díjszabási.

Az adatbázist az Azure SQL Database-ben fogja üzembe helyezni. Az SQL Database egy felhőalapú relációsadatbázis-szolgáltatás, amely SQL Server-technológiákra épül. Az SQL Serverrel dolgozó eszközök és alkalmazások az SQL-adatbázissal is működnek.

Az Azure Management Portalbal oldali lapján válassza az Erőforrás létrehozása lehetőséget, majd válassza a Mindent megtekint opciót az Új ablakban (vagy ablak) az összes rendelkezésre álló erőforrás megtekintéséhez. A Minden panel Web részében válassza a Web App + SQL lehetőséget. Végül válassza a létrehozása lehetőséget.

Megnyílik az új New Web App + SQL erőforrás létrehozásához létrehozott űrlap.
Írjon be egy sztringet a alkalmazásnév mezőbe, amely az alkalmazás egyedi URL-címeként használható. A teljes URL-cím az itt megadottakból és az Azure App Services (.azurewebsites.net) alapértelmezett tartományából áll. Ha a alkalmazásnév már foglalt, a Varázsló piros Az alkalmazás neve nem érhető el üzenettel értesít. Ha elérhető az alkalmazásnév, megjelenik egy zöld pipa.
Az Előfizetési mezőben válassza ki azt az Azure-előfizetést, amelyben a App Service- található.
Az Erőforráscsoport szövegmezőben válasszon egy erőforráscsoportot, vagy hozzon létre egy újat. Ez a beállítás határozza meg, hogy a webhely melyik adatközpontban fog futni. További információ az erőforráscsoportokról: Erőforráscsoportok.
Hozzon létre egy új App Service tervet a App Service szakaszra kattintva, majd válassza az Új létrehozásalehetőséget. Töltse ki a App Service tervet (ugyanaz a név lehet, mint az App Service), a Helyetés a Díjszabási szintet (van egy ingyenes lehetőség).
Kattintson SQL Database, majd válassza az Új adatbázis létrehozása lehetőséget, vagy válasszon ki egy meglévő adatbázist.
A Név mezőbe írja be az adatbázis nevét.
Kattintson a Célkiszolgáló mezőbe, majd válassza Új kiszolgáló létrehozásalehetőséget. Másik lehetőségként, ha korábban létrehozott egy kiszolgálót, kiválaszthatja a kiszolgálót az elérhető kiszolgálók listájából.
Válassza Tarifacsomag szakaszt, majd válassza Ingyeneslehetőséget. Ha további erőforrásokra van szükség, az adatbázis bármikor felskálázható. További információ az Azure SQL díjszabásáról, lásd: Azure SQL Database díjszabás.
Szükség szerint módosítsa a rendezési beállításokat.
Adjon meg egy rendszergazdai SQL-rendszergazdai felhasználónevet és egy SQL-rendszergazdai jelszót.
- Ha Új SQL Database-kiszolgálólehetőséget választotta, adjon meg egy új nevet és jelszót, amelyet később fog használni az adatbázis elérésekor.
- Ha korábban létrehozott kiszolgálót választott, adja meg a kiszolgáló hitelesítő adatait.
A telemetriai gyűjtemény az App Service-ben engedélyezhető az Application Insights használatával. Kevés konfigurációval az Application Insights értékes eseményeket, kivételeket, függőségeket, kéréseket és nyomkövetési információkat gyűjt. További információért az Application Insightsról nézze meg az Azure Monitor.
Kattints a "Create" gombra alul, hogy jelezd, hogy elkészültél.

A kezelői portál visszatér az Irányítópultra, és a lap tetején található Értesítések terület azt mutatja, hogy a webhely létrehozása folyamatban van. Egy idő után (általában kevesebb, mint egy perc) megjelenik egy értesítés arról, hogy az üzembe helyezés sikeres volt. A bal oldali navigációs sávon az új App Service az App Services szakaszban, az új SQL-adatbázis pedig az SQL-adatbázisok szakaszban jelenik meg.

Az alkalmazás üzembe helyezése az Azure-ban

A Visual Studióban kattintson a jobb gombbal a projektre Megoldáskezelő, és válassza a helyi menüben a Közzététel lehetőséget.
A Válasszon közzétételi cél lapot, válassza az App Service lehetőséget, majd válassza ki a Meglévőlehetőséget, majd válassza a Közzététellehetőséget.
Ha korábban még nem adta hozzá Azure-előfizetését a Visual Studióban, hajtsa végre a lépéseket a képernyőn. Ezek a lépések lehetővé teszik a Visual Studio számára az Azure-előfizetéshez való csatlakozást, hogy a App Services listája tartalmazza a webhelyét.
Az App Service lapján válassza ki azt a előfizetést, amelybe hozzáadta az App Service-t. A Nézetterületen válassza ki az Erőforráscsoportlehetőséget. Bontsa ki azt az erőforráscsoportot, amelybe hozzáadta az App Service-t, majd válassza ki az App Service-t. Az alkalmazás közzétételéhez válassza az OK lehetőséget.
A Kimeneti ablakban látható, hogy milyen üzembe helyezési műveleteket hajtottak végre, és az üzembe helyezés sikeres befejezését jelenti.
Sikeres üzembe helyezés esetén az alapértelmezett böngésző automatikusan megnyílik az üzembe helyezett webhely URL-címére.

Az alkalmazás most már a felhőben fut.

Ezen a ponton a SchoolContext adatbázis létrejött az Azure SQL-adatbázisban, mert kiválasztotta a Első migrációk végrehajtása a kód alapján (az alkalmazás indításakor fut)opciót. Az üzembe helyezett webhelyen lévő Web.config fájl módosult, így a MigrateDatabaseToLatestVersion inicializálója az első alkalommal fut, amikor a kód először olvas vagy ír adatokat az adatbázisban (ami a Diákok lap kiválasztásakor történt):

Web.config fájlrészlet

Az üzembe helyezési folyamat egy új kapcsolati sztringet is létrehozott (SchoolContext_DatabasePublish) a Code First Migrations számára, amely az adatbázisséma frissítéséhez és az adatbázis üzembe helyezéséhez használható.

kapcsolati karakterlánc Web.config fájlban

A Web.config fájl telepített verzióját a saját számítógépén találja a ContosoUniversity\obj\Release\Package\PackageTmp\Web.config. A telepített Web.config fájlt az FTP használatával érheti el. Útmutatásért lásd: ASP.NET Web Deployment using Visual Studio: Deploying a Code Update. Kövesse az "FTP-eszköz használatához három dologra van szükség: az FTP URL-címére, a felhasználónévre és a jelszóra".

Jegyzet

A webalkalmazás nem implementálja a biztonságot, így bárki, aki megtalálja az URL-címet, módosíthatja az adatokat. A webhely biztonságossá tételével kapcsolatos utasításokért lásd: Biztonságos ASP.NET MVC-alkalmazás üzembe helyezése tagsággal, OAuth- és SQL-adatbázissal az Azure. Megakadályozhatja, hogy mások is használják a webhelyet, ha leállítja a szolgáltatást az Azure Management Portalon vagy Server Explorer a Visual Studióban.

App Service leállítása menüelem

Speciális migrálási forgatókönyvek

Ha az oktatóanyagban látható módon automatikusan telepíti az adatbázist az áttelepítések automatikus futtatásával, és egy több kiszolgálón futó webhelyen helyezi üzembe az adatbázist, egyszerre több kiszolgálót is lekérhet az áttelepítések futtatására. Az áttelepítések atomiak, ezért ha két kiszolgáló ugyanazt az áttelepítést próbálja futtatni, az egyik sikeres lesz, a másik sikertelen lesz (feltéve, hogy a műveleteket nem lehet kétszer elvégezni). Ebben a forgatókönyvben, ha el szeretné kerülni ezeket a problémákat, manuálisan hívhatja meg az áttelepítéseket, és beállíthatja a saját kódját, hogy az csak egyszer történjen meg. További információt Rowan Miller blogján és Migrate.exe (a parancssorból történő migrálások végrehajtásához) a A kód-ból való futtatása és szkriptelése című témakörben talál.

További információ az egyéb migrálási forgatókönyvekről: Migrations Screencast Series.

Konkrét migrálás frissítése

update-database -target MigrationName

A update-database -target MigrationName parancs futtatja a célzott migrálást.

Adatbázis migrálási módosításainak figyelmen kívül hagyása

Add-migration MigrationName -ignoreChanges

ignoreChanges létrehoz egy üres migrációt az aktuális modell pillanatképeként.

Kód első inicializálói

Az üzembe helyezési szakaszban látta, hogy a MigrateDatabaseToLatestVersion inicializáló használatban van. A Code First más inicializálókat is biztosít, például CreateDatabaseIfNotExists (alapértelmezett), DropCreateDatabaseIfModelChanges (amelyet korábban használt), és DropCreateDatabaseAlways. Az DropCreateAlways inicializáló hasznos lehet az egységtesztek feltételeinek beállításához. Saját inicializálókat is írhat, és explicit módon is meghívhat egy inicializálót, ha nem szeretne megvárni, amíg az alkalmazás beolvassa az adatbázist, vagy nem ír az adatbázisba.

További információért az inicializálókról tekintse meg az Adatbázis-inicializálók ismertetése az Entity Framework Code First-ben és a Programming Entity Framework: Code First című könyv 6. fejezetét, melyet Julie Lerman és Rowan Miller írtak.

A kód lekérése

Befejezett projekt letöltése

További erőforrások

Más entity framework-erőforrásokra mutató hivatkozások ASP.NET Adathozzáférés – Ajánlott erőforrásokcímű témakörben találhatók.

Következő lépések