Samouczek: korzystanie z migracji ef w aplikacji MVC ASP.NET i wdrażanie na platformie Azure

Do tej pory przykładowa aplikacja internetowa Contoso University działa lokalnie w IIS Express na komputerze deweloperskim. Aby udostępnić prawdziwą aplikację innym osobom do użycia przez Internet, musisz wdrożyć ją u dostawcy hostingu internetowego. W tym samouczku włączysz migracje Code First i wdrożysz aplikację w chmurze na platformie Azure:

  • Włącz Migracje Code First. Funkcja Migracje umożliwia zmianę modelu danych i wdrożenie zmian w środowisku produkcyjnym przez zaktualizowanie schematu bazy danych bez konieczności porzucania i ponownego tworzenia bazy danych.
  • Wdrażanie na platformie Azure. Ten krok jest opcjonalny; Możesz kontynuować pracę z pozostałymi samouczkami bez konieczności wdrażania projektu.

Zalecamy używanie procesu ciągłej integracji z kontrolą źródła do wdrożenia, ale ten samouczek nie obejmuje tych tematów. Aby uzyskać więcej informacji, zobacz rozdziały kontroli źródła i ciągłej integracji w temacie Building Real-World Cloud Apps with Azure (Tworzenie aplikacji w chmurze Real-World za pomocą platformy Azure).

W tym samouczku zostały wykonane następujące czynności:

  • Włączanie migracji Code First
  • Wdrażanie aplikacji na platformie Azure (opcjonalnie)

Wymagania wstępne

Włączanie migracji Code First

Podczas opracowywania nowej aplikacji model danych zmienia się często i za każdym razem, gdy model ulegnie zmianie, nie jest synchronizowany z bazą danych. Skonfigurowano program Entity Framework do automatycznego porzucania i ponownego tworzenia bazy danych za każdym razem, gdy zmieniasz model danych. Gdy dodasz, usuniesz lub zmienisz klasy jednostek lub zmienisz DbContext klasę, przy następnym uruchomieniu aplikacji automatycznie usunie istniejącą bazę danych, zostanie utworzona nowa, która jest zgodna z modelem, i rozmieszcza ją danymi testowymi.

Ta metoda synchronizacji bazy danych z modelem danych działa dobrze do momentu wdrożenia aplikacji w środowisku produkcyjnym. Gdy aplikacja jest uruchomiona w środowisku produkcyjnym, zwykle przechowuje dane, które chcesz zachować, i nie chcesz tracić wszystkiego za każdym razem, gdy wprowadzasz zmiany, takie jak dodawanie nowej kolumny. Funkcja Migracje Code First rozwiązuje ten problem, włączając funkcję Code First w celu zaktualizowania schematu bazy danych zamiast upuszczania i ponownego tworzenia bazy danych. W tym samouczku wdrożysz aplikację i przygotujesz się do jej włączenia.

  1. Wyłącz inicjator, który został skonfigurowany wcześniej, komentując lub usuwając contexts element dodany do pliku Web.config aplikacji.

    <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>
    
  2. Również w pliku Web.config aplikacji zmień nazwę bazy danych w parametrach połączenia na ContosoUniversity2.

    <connectionStrings>
      <add name="SchoolContext" connectionString="Data Source=(LocalDb)\MSSQLLocalDB;Initial Catalog=ContosoUniversity2;Integrated Security=SSPI;" providerName="System.Data.SqlClient" />
    </connectionStrings>
    

    Ta zmiana powoduje skonfigurowanie projektu tak, aby pierwsza migracja utworzyła nową bazę danych. Nie jest to wymagane, ale zobaczysz później, dlaczego jest to dobry pomysł.

  3. Z menu Narzędzia wybierz pozycję Konsola menedżera pakietów NuGetPackage Manager>.

  4. PM> W wierszu polecenia wprowadź następujące polecenia:

    enable-migrations
    add-migration InitialCreate
    

    Polecenie enable-migrations tworzy folder Migrations w projekcie ContosoUniversity i umieszcza w tym folderze plik Configuration.cs , który można edytować w celu skonfigurowania migracji.

    (Jeśli pominięto powyższy krok, który przekierowuje Cię do zmiany nazwy bazy danych, migracje znajdą istniejącą bazę danych i automatycznie wykonaj add-migration polecenie . W porządku, oznacza to, że nie uruchomisz testu kodu migracji przed wdrożeniem bazy danych. Później po uruchomieniu update-database polecenia nic się nie stanie, ponieważ baza danych już istnieje.

    Otwórz plik ContosoUniversity\Migrations\Configuration.cs . Podobnie jak w przypadku klasy inicjatora, którą widzieliśmy wcześniej, Configuration klasa zawiera metodę Seed .

    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" }
            //    );
            //
        }
    }
    

    Celem metody Seed jest umożliwienie wstawiania lub aktualizowania danych testowych po utworzeniu lub zaktualizowaniu bazy danych przez funkcję Code First. Metoda jest wywoływana podczas tworzenia bazy danych i za każdym razem, gdy schemat bazy danych jest aktualizowany po zmianie modelu danych.

Konfigurowanie metody Seed

Po usunięciu i ponownym utworzeniu bazy danych dla każdej zmiany modelu danych użyjesz metody klasy inicjatora Seed , aby wstawić dane testowe, ponieważ po każdej zmianie modelu baza danych zostanie porzucona i wszystkie dane testowe zostaną utracone. W przypadku Migracje Code First dane testowe są zachowywane po zmianie bazy danych, więc uwzględnienie danych testowych w metodzie Seed zwykle nie jest konieczne. W rzeczywistości nie chcesz Seed , aby metoda wstawiać dane testowe, jeśli będziesz używać funkcji Migrations do wdrożenia bazy danych w środowisku produkcyjnym, ponieważ Seed metoda zostanie uruchomiona w środowisku produkcyjnym. W takim przypadku chcesz Seed , aby metoda wstawiła do bazy danych tylko te dane, które są potrzebne w środowisku produkcyjnym. Na przykład możesz chcieć, aby baza danych zawierała rzeczywiste nazwy działów w Department tabeli, gdy aplikacja stanie się dostępna w środowisku produkcyjnym.

W tym samouczku będziesz używać funkcji Migracje do wdrożenia, ale Seed metoda mimo to wstawi dane testowe, aby ułatwić sprawdzenie, jak działa funkcja aplikacji bez konieczności ręcznego wstawiania dużej ilości danych.

  1. Zastąp zawartość pliku Configuration.cs następującym kodem, który ładuje dane testowe do nowej bazy danych.

    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();
            }
        }
    }
    

    Metoda Seed przyjmuje obiekt kontekstu bazy danych jako parametr wejściowy, a kod w metodzie używa tego obiektu do dodawania nowych jednostek do bazy danych. Dla każdego typu jednostki kod tworzy kolekcję nowych jednostek, dodaje je do odpowiedniej właściwości DbSet , a następnie zapisuje zmiany w bazie danych. Nie jest konieczne wywołanie metody SaveChanges po każdej grupie jednostek, podobnie jak w tym miejscu, ale pomaga zlokalizować źródło problemu, jeśli wystąpi wyjątek podczas zapisywania kodu w bazie danych.

    Niektóre instrukcje, które wstawiają dane, używają metody AddOrUpdate do wykonania operacji "upsert". Seed Ponieważ metoda jest uruchamiana za każdym razem, gdy wykonujesz update-database polecenie, zazwyczaj po każdej migracji, nie można po prostu wstawić danych, ponieważ wiersze, które próbujesz dodać, będą już dostępne po pierwszej migracji, która tworzy bazę danych. Operacja "upsert" uniemożliwia błędy, które mogą wystąpić w przypadku próby wstawienia wiersza, który już istnieje, ale zastępuje wszelkie zmiany danych, które mogły zostać wprowadzone podczas testowania aplikacji. W przypadku danych testowych w niektórych tabelach możesz nie chcieć tego dokonać: w niektórych przypadkach, gdy zmieniasz dane podczas testowania, czy zmiany mają pozostać po zaktualizowaniu bazy danych. W takim przypadku chcesz wykonać operację wstawiania warunkowego: wstaw wiersz tylko wtedy, gdy jeszcze nie istnieje. Metoda Seed używa obu metod.

    Pierwszy parametr przekazany do metody AddOrUpdate określa właściwość używaną do sprawdzania, czy wiersz już istnieje. W przypadku danych testowych uczniów, które podajesz, właściwość może być używana do tego celu, LastName ponieważ każde nazwisko na liście jest unikatowe:

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

    W tym kodzie przyjęto założenie, że nazwiska są unikatowe. Jeśli ręcznie dodasz ucznia z zduplikowaną nazwą, otrzymasz następujący wyjątek przy następnej migracji:

    Sekwencja zawiera więcej niż jeden element

    Aby uzyskać informacje o sposobie obsługi nadmiarowych danych, takich jak dwóch uczniów o nazwie "Alexander Carson", zobacz Seeding and Debugging Entity Framework (EF) DBs (Seeding and Debugging Entity Framework) (Bazy danych platformy Entity Framework (EF) na blogu Ricka Andersona. Aby uzyskać więcej informacji na temat AddOrUpdate metody, zobacz Artykuł Take care with EF 4.3 AddOrUpdate Method on Julie Lerman's blog (Metoda AddOrUpdate platformy EF 4.3 w blogu Julie Lerman).

    Kod tworzący jednostki zakłada, że Enrollment masz ID wartość w jednostkach w students kolekcji, chociaż nie ustawiono tej właściwości w kodzie tworzącym kolekcję.

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

    W tym miejscu możesz użyć ID właściwości , ponieważ ID wartość jest ustawiana podczas wywoływania SaveChanges kolekcji students . Program EF automatycznie pobiera wartość klucza podstawowego podczas wstawiania jednostki do bazy danych i aktualizuje ID właściwość jednostki w pamięci.

    Kod, który dodaje każdą Enrollment jednostkę do Enrollments zestawu jednostek, nie używa AddOrUpdate metody . Sprawdza, czy jednostka już istnieje i wstawia jednostkę, jeśli nie istnieje. Takie podejście spowoduje zachowanie zmian w klasie rejestracji przy użyciu interfejsu użytkownika aplikacji. Kod przechodzi w pętli przez każdy element członkowski Enrollmentlisty i jeśli rejestracja nie zostanie znaleziona w bazie danych, dodaje rejestrację do bazy danych. Podczas pierwszej aktualizacji bazy danych baza danych będzie pusta, więc doda każdą rejestrację.

    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);
        }
    }
    
  2. Skompiluj projekt.

Wykonywanie pierwszej migracji

Po wykonaniu add-migration polecenia migracje wygenerowały kod, który tworzy bazę danych od podstaw. Ten kod znajduje się również w folderze Migrations w pliku o nazwie <timestamp>_InitialCreate.cs. Metoda UpInitialCreate klasy tworzy tabele bazy danych, które odpowiadają zestawom jednostek modelu danych, a Down metoda je usuwa.

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");
    }
}

Migracje wywołuje metodę Up w celu zaimplementowania zmian modelu danych na potrzeby migracji. Po wprowadzeniu polecenia w celu cofnięcia aktualizacji funkcja Migrations wywołuje metodę Down .

Jest to początkowa migracja utworzona podczas wprowadzania add-migration InitialCreate polecenia. Parametr (InitialCreate w przykładzie) jest używany dla nazwy pliku i może być dowolny; zazwyczaj wybierasz słowo lub frazę, która podsumowuje, co jest wykonywane w migracji. Na przykład można nazwać późniejszą migrację "AddDepartmentTable".

Jeśli migracja początkowa została utworzona, gdy baza danych już istnieje, zostanie wygenerowany kod tworzenia bazy danych, ale nie trzeba go uruchamiać, ponieważ baza danych jest już zgodna z modelem danych. Po wdrożeniu aplikacji w innym środowisku, w którym baza danych jeszcze nie istnieje, ten kod zostanie uruchomiony w celu utworzenia bazy danych, dlatego warto go najpierw przetestować. Dlatego wcześniej zmieniono nazwę bazy danych w parametrach połączenia, aby migracje mogły utworzyć nową od podstaw.

  1. W oknie Konsola menedżera pakietów wprowadź następujące polecenie:

    update-database

    Polecenie update-database uruchamia metodę Up , aby utworzyć bazę danych, a następnie uruchamia metodę Seed w celu wypełnienia bazy danych. Ten sam proces zostanie uruchomiony automatycznie w środowisku produkcyjnym po wdrożeniu aplikacji, jak pokazano w poniższej sekcji.

  2. Użyj Eksploratora serwera , aby sprawdzić bazę danych tak jak w pierwszym samouczku i uruchomić aplikację, aby sprawdzić, czy wszystko nadal działa tak samo jak poprzednio.

Wdróż na platformie Azure

Do tej pory aplikacja była uruchomiona lokalnie w IIS Express na komputerze dewelopera. Aby udostępnić go innym osobom do użycia przez Internet, należy wdrożyć go u dostawcy hostingu internetowego. W tej sekcji samouczka wdrożysz ją na platformie Azure. Ta sekcja jest opcjonalna; Możesz pominąć ten samouczek i kontynuować pracę z poniższym samouczkiem lub dostosować instrukcje w tej sekcji dla innego wybranego dostawcy hostingu.

Wdrażanie bazy danych przy użyciu migracji Code First

Aby wdrożyć bazę danych, użyjesz Migracje Code First. Podczas tworzenia profilu publikowania używanego do konfigurowania ustawień wdrażania z poziomu programu Visual Studio zaznacz pole wyboru z etykietą Aktualizuj bazę danych. To ustawienie powoduje, że proces wdrażania automatycznie konfiguruje plik Web.config aplikacji na serwerze docelowym, tak aby program Code First używał klasy inicjatora MigrateDatabaseToLatestVersion .

Program Visual Studio nie wykonuje żadnych czynności z bazą danych podczas procesu wdrażania podczas kopiowania projektu na serwer docelowy. Po uruchomieniu wdrożonej aplikacji uzyskuje ona dostęp do bazy danych po raz pierwszy po wdrożeniu, Funkcja Code First sprawdza, czy baza danych jest zgodna z modelem danych. Jeśli występuje niezgodność, funkcja Code First automatycznie tworzy bazę danych (jeśli jeszcze nie istnieje) lub aktualizuje schemat bazy danych do najnowszej wersji (jeśli baza danych istnieje, ale nie jest zgodna z modelem). Jeśli aplikacja implementuje metodę Migrations Seed , metoda jest uruchamiana po utworzeniu bazy danych lub zaktualizowaniu schematu.

Metoda Migrations Seed wstawia dane testowe. W przypadku wdrożenia w środowisku produkcyjnym należy zmienić Seed metodę tak, aby wstawiała tylko dane, które mają zostać wstawione do produkcyjnej bazy danych. Na przykład w bieżącym modelu danych możesz mieć prawdziwe kursy, ale fikcyjnych studentów w bazie danych deweloperskich. Możesz napisać metodę Seed ładowania zarówno w środowisku deweloperskim, jak i skomentować fikcyjnych uczniów przed wdrożeniem w środowisku produkcyjnym. Możesz też napisać metodę Seed ładowania tylko kursów i wprowadzić fikcyjnych uczniów w testowej bazie danych ręcznie przy użyciu interfejsu użytkownika aplikacji.

Pobieranie konta platformy Azure

Musisz mieć konto platformy Azure. Jeśli jeszcze go nie masz, ale masz subskrypcję programu Visual Studio, możesz aktywować korzyści z subskrypcji. W przeciwnym razie możesz utworzyć bezpłatne konto w wersji próbnej w ciągu zaledwie kilku minut. Aby uzyskać szczegółowe informacje, zobacz Bezpłatna wersja próbna platformy Azure.

Tworzenie witryny internetowej i bazy danych SQL na platformie Azure

Aplikacja internetowa na platformie Azure zostanie uruchomiona w udostępnionym środowisku hostingu, co oznacza, że działa na maszynach wirtualnych udostępnionych innym klientom platformy Azure. Współużytkowane środowisko hostingu to ekonomiczny sposób rozpoczęcia pracy w chmurze. Później, jeśli ruch internetowy wzrośnie, aplikacja może skalować w celu zaspokojenia potrzeb, uruchamiając na dedykowanych maszynach wirtualnych. Aby dowiedzieć się więcej na temat opcji cen dla Azure App Service, przeczytaj App Service cennik.

Wdróżysz bazę danych w Azure SQL bazie danych. Baza danych SQL to oparta na chmurze usługa relacyjnej bazy danych oparta na technologii SQL Server. Narzędzia i aplikacje, które współpracują z SQL Server również współdziałają z bazą danych SQL.

  1. W witrynie Azure Management Portal wybierz pozycję Utwórz zasób na lewej karcie, a następnie wybierz pozycję Zobacz wszystko w okienkuNowy (lub blok), aby wyświetlić wszystkie dostępne zasoby. Wybierz pozycję Aplikacja internetowa + SQL w sekcji Sieci Web bloku Wszystko . Na koniec wybierz pozycję Utwórz.

    Tworzenie zasobu w witrynie Azure Portal

    Zostanie otwarty formularz umożliwiający utworzenie nowej aplikacji internetowej i zasobu SQL .

  2. Wprowadź ciąg w polu Nazwa aplikacji , który ma być używany jako unikatowy adres URL aplikacji. Pełny adres URL będzie składał się z wprowadzonego tutaj elementu oraz domeny domyślnej usług aplikacja systemu Azure (.azurewebsites.net). Jeśli nazwa aplikacji jest już zajęta, Kreator powiadomi Cię o czerwonej nazwie aplikacji nie jest dostępny . Jeśli nazwa aplikacji jest dostępna, zostanie wyświetlony zielony znacznik wyboru.

  3. W polu Subskrypcja wybierz subskrypcję platformy Azure, w której ma znajdować się App Service.

  4. W polu tekstowym Grupa zasobów wybierz grupę zasobów lub utwórz nową. To ustawienie określa, w którym centrum danych będzie działać witryna internetowa. Aby uzyskać więcej informacji na temat grup zasobów, zobacz Grupy zasobów.

  5. Utwórz nowy plan App Service, klikając sekcję App Service, Utwórz nowy i wypełnij plan App Service (może być taki sam jak App Service), Lokalizacja i Warstwa cenowa (dostępna jest bezpłatna opcja).

  6. Kliknij SQL Database, a następnie wybierz pozycję Utwórz nową bazę danych lub wybierz istniejącą bazę danych.

  7. W polu Nazwa wprowadź nazwę bazy danych.

  8. Kliknij pole Serwer docelowy , a następnie wybierz pozycję Utwórz nowy serwer. Alternatywnie, jeśli wcześniej utworzono serwer, możesz wybrać ten serwer z listy dostępnych serwerów.

  9. Wybierz sekcję Warstwa cenowa , wybierz pozycję Bezpłatna. Jeśli potrzebne są dodatkowe zasoby, bazę danych można skalować w górę w dowolnym momencie. Aby dowiedzieć się więcej na temat cen Azure SQL, zobacz cennik usługi Azure SQL Database.

  10. Zmodyfikuj sortowanie zgodnie z potrzebami.

  11. Wprowadź nazwę użytkownika usługi SQL Administracja administratora i hasło Administracja SQL.

    • W przypadku wybrania opcji Nowy serwer SQL Database zdefiniuj nową nazwę i hasło, które będzie używane później podczas uzyskiwania dostępu do bazy danych.
    • Jeśli wybrano wcześniej utworzony serwer, wprowadź poświadczenia dla tego serwera.
  12. Zbieranie danych telemetrycznych można włączyć dla App Service przy użyciu usługi Application Insights. Przy małej konfiguracji usługa Application Insights zbiera cenne zdarzenia, wyjątki, zależność, żądanie i informacje dotyczące śledzenia. Aby dowiedzieć się więcej na temat usługi Application Insights, zobacz Azure Monitor.

  13. Kliknij przycisk Utwórz u dołu, aby wskazać, że skończysz.

    Portal zarządzania powraca do strony Pulpit nawigacyjny, a obszar Powiadomienia w górnej części strony pokazuje, że witryna jest tworzona. Po pewnym czasie (zazwyczaj mniej niż minutę) zostanie wyświetlone powiadomienie o pomyślnym wdrożeniu. Na pasku nawigacyjnym po lewej stronie zostanie wyświetlona nowa App Service w sekcji Usługi App Services, a nowa baza danych SQL zostanie wyświetlona w sekcji Bazy danych SQL.

Wdrażanie aplikacji na platformie Azure

  1. W programie Visual Studio kliknij prawym przyciskiem myszy projekt w Eksplorator rozwiązań i wybierz polecenie Publikuj z menu kontekstowego.

  2. Na stronie Wybierz element docelowy publikowania wybierz pozycję App Service, a następnie wybierz pozycję Wybierz istniejącą, a następnie wybierz pozycję Publikuj.

    Wybieranie strony docelowej publikowania

  3. Jeśli wcześniej nie dodano subskrypcji platformy Azure w programie Visual Studio, wykonaj kroki na ekranie. Te kroki umożliwiają programowi Visual Studio nawiązanie połączenia z subskrypcją platformy Azure, aby lista usług App Services zawierała witrynę internetową.

  4. Na stronie App Service wybierz subskrypcję, do której dodano App Service. W obszarze Widok wybierz pozycję Grupa zasobów. Rozwiń grupę zasobów, do której dodano App Service, a następnie wybierz App Service. Wybierz przycisk OK , aby opublikować aplikację.

  5. W oknie Dane wyjściowe przedstawiono akcje wdrożenia i raporty pomyślnego ukończenia wdrożenia.

  6. Po pomyślnym wdrożeniu domyślna przeglądarka automatycznie otwiera adres URL wdrożonej witryny sieci Web.

    Students_index_page_with_paging

    Twoja aplikacja działa teraz w chmurze.

W tym momencie baza danych SchoolContext została utworzona w bazie danych Azure SQL, ponieważ wybrano pozycję Wykonaj Migracje Code First (działa na początku aplikacji). Plik Web.config w wdrożonej witrynie sieci Web został zmieniony tak, aby inicjator MigrateDatabaseToLatestVersion uruchamiał pierwszy raz, gdy kod odczytuje lub zapisuje dane w bazie danych (co miało miejsce po wybraniu karty Uczniowie ):

 fragment plikuWeb.config

Proces wdrażania utworzył również nowe parametry połączenia (SchoolContext_DatabasePublish) dla Migracje Code First do użycia do aktualizowania schematu bazy danych i rozmieszczania bazy danych.

Parametry połączenia w pliku Web.config

Wdrożoną wersję pliku Web.config można znaleźć na własnym komputerze w ContosoUniversity\obj\Release\Package\PackageTmp\Web.config. Dostęp do wdrożonego pliku Web.config można uzyskać za pomocą protokołu FTP. Aby uzyskać instrukcje, zobacz ASP.NET Web Deployment using Visual Studio: Deploying a Code Update (Wdrażanie aktualizacji kodu przy użyciu programu Visual Studio: wdrażanie aktualizacji kodu). Postępuj zgodnie z instrukcjami rozpoczynającymi się od "Aby użyć narzędzia FTP, potrzebne są trzy elementy: adres URL FTP, nazwa użytkownika i hasło".

Uwaga

Aplikacja internetowa nie implementuje zabezpieczeń, więc każdy, kto znajdzie adres URL, może zmienić dane. Aby uzyskać instrukcje dotyczące zabezpieczania witryny internetowej, zobacz Deploy a Secure ASP.NET MVC app with Membership, OAuth i SQL Database to Azure (Wdrażanie aplikacji Secure ASP.NET MVC przy użyciu członkostwa, uwierzytelniania OAuth i bazy danych SQL database na platformie Azure). Możesz uniemożliwić innym osobom korzystanie z witryny, zatrzymując usługę przy użyciu portalu zarządzania Azure lub Eksploratora serwera w programie Visual Studio.

Zatrzymaj element menu usługi App Service

Zaawansowane scenariusze migracji

Jeśli wdrożysz bazę danych, uruchamiając migracje automatycznie, jak pokazano w tym samouczku, i wdrażasz w witrynie internetowej działającej na wielu serwerach, możesz jednocześnie uruchomić migracje wielu serwerów. Migracje są niepodzielne, więc jeśli dwa serwery spróbują uruchomić tę samą migrację, jeden powiedzie się, a drugi zakończy się niepowodzeniem (przy założeniu, że operacje nie można wykonać dwa razy). W tym scenariuszu, jeśli chcesz uniknąć tych problemów, możesz wywołać migracje ręcznie i skonfigurować własny kod, tak aby odbywało się to tylko raz. Aby uzyskać więcej informacji, zobacz Running and Scripting Migrations from Code on Rowan Miller's blog andMigrate.exe(for running and Scripting Migrations from Code on Rowan Miller's blog and Migrate.exe (w celu wykonywania migracji z wiersza polecenia).

Aby uzyskać informacje na temat innych scenariuszy migracji, zobacz Migracje screencast Series.

Aktualizowanie określonej migracji

update-database -target MigrationName

Polecenie update-database -target MigrationName uruchamia migrację docelową.

Ignoruj zmiany migracji do bazy danych

Add-migration MigrationName -ignoreChanges

ignoreChanges Tworzy pustą migrację przy użyciu bieżącego modelu jako migawki.

Inicjatory Code First

W sekcji wdrażania zobaczysz używany inicjator MigrateDatabaseToLatestVersion . Code First udostępnia również inne inicjatory, w tym CreateDatabaseIfNotExists (wartość domyślna), DropCreateDatabaseIfModelChanges (które były używane wcześniej) i DropCreateDatabaseAlways. Inicjator DropCreateAlways może być przydatny do konfigurowania warunków testów jednostkowych. Możesz również napisać własne inicjatory i jawnie wywołać inicjator, jeśli nie chcesz czekać, aż aplikacja odczytuje dane z bazy danych ani nie zapisuje ich w bazie danych.

Aby uzyskać więcej informacji na temat inicjatorów, zobacz Understanding Database Initializers in Entity Framework Code First and chapter 6 of the book Programming Entity Framework: Code First by Julie Lerman and Rowan Miller (Opis inicjatorów baz danych w kodzie jednostki i rozdział 6 książki Programming Entity Framework: Code First by Julie Lerman i Rowan Miller).

Uzyskiwanie kodu

Pobieranie ukończonego projektu

Dodatkowe zasoby

Linki do innych zasobów platformy Entity Framework można znaleźć w ASP.NET Dostęp do danych — zalecane zasoby.

Następne kroki

W tym samouczku zostały wykonane następujące czynności:

  • Włączone migracje Code First
  • Wdrożono aplikację na platformie Azure (opcjonalnie)

Przejdź do następnego artykułu, aby dowiedzieć się, jak utworzyć bardziej złożony model danych dla aplikacji MVC ASP.NET.