Skapa en Ruby- och Postgres-app i Azure App Service på Linux

Azure App Service en mycket skalbar och självkorrigering av webbvärdtjänsten. I den här självstudien visas hur du skapar en Ruby-app och ansluter den till en PostgreSQL-databas. När du är klar har du en Ruby on Rails-app som körs i App Service på Linux.

I den här guiden får du lära dig att:

Om du inte har en Azure-prenumerationkan du skapa ett kostnads fritt konto innan du börjar.

Förutsättningar

För att slutföra den här kursen behöver du:

• Installera Git
• Installera Ruby 2.6
• Installera Ruby on Rails 5.1
• Installera och kör PostgreSQL

• Använd bash-miljön i Azure Cloud Shell.

  

• Om du vill kan du i stället installera Azure CLI för att köra CLI-referenskommandon.

  • Om du använder en lokal installation loggar du in på Azure CLI med hjälp av kommandot az login. Slutför autentiseringsprocessen genom att följa stegen som visas i terminalen. Fler inloggningsalternativ finns i Logga in med Azure CLI.

  • När du uppmanas till det installerar du Azure CLI-tillägg vid första användning. Mer information om tillägg finns i Använda tillägg med Azure CLI.

  • Kör az version om du vill hitta versionen och de beroende bibliotek som är installerade. Om du vill uppgradera till den senaste versionen kör du az upgrade.

Förbereda lokala Postgres

I det här steget skapar du en databas för självstudien på din lokala Postgres-server.

Anslut till den lokala Postgres-servern

1. Öppna terminalfönstret och kör psql för att ansluta till din lokala Postgres-server.

   sudo -u postgres psql
   

   Om anslutningen lyckas körs Postgres-databasen. Om inte, kontrollerar du att den lokala Postgres-databasen har startats genom att följa stegen i Hämtningar – PostgreSQL Core Distribution.

2. Skriv \q om du vill avsluta Postgres-klienten.

3. Skapa en Postgres-användare som kan skapa databaser genom att köra följande kommando, med ditt inloggade Linux-användarnamn.

   sudo -u postgres createuser -d <signed-in-user>
   

Skapa en Ruby on Rails-app lokalt

I det här steget hämtar du en Ruby on Rails-exempelapp, konfigurerar dess databasanslutning och kör den lokalt.

Klona exemplet

1. Använd kommandot cd för att komma till en arbetskatalog i terminalfönstret.

2. Klona exempeldatabasen och ändra till lagringsplatsens rot.

   git clone https://github.com/Azure-Samples/rubyrails-tasks.git
   cd rubyrails-tasks
   

3. Kontrollera att standardgrenen är main .

   git branch -m main
   

   Tips

   Ändringen av grennamnet krävs inte av App Service. Men eftersom många lagringslager ändrar sin standardgren till visar den här självstudien även main hur du distribuerar en lagringsplats från main . Mer information finns i Ändra distributionsgren.

4. Installera de paket som behövs.

   bundle install --path vendor/bundle
   

Köra exemplet lokalt

1. Kör Rails-migreringen för att skapa de tabeller som behövs för appen. Du kan se vilka tabeller som skapas i migreringarna i katalogen db/migrations på Git-lagringsplatsen.

   rake db:create
   rake db:migrate
   

2. Kör appen.

   rails server
   

3. Gå till http://localhost:3000 i en webbläsare. Lägg till några uppgifter på sidan.

   

4. Om du vill stoppa Rails-servern skriver du Ctrl + C i terminalen.

Skapa Postgres i Azure

I det här steget skapar du en Postgres-databas i Azure Database for PostgreSQL. Senare kommer du att konfigurera Ruby on Rails-appen för att ansluta till den här databasen.

Skapa en resursgrupp

En resurs grupp är en logisk behållare där Azure-resurser, till exempel webbappar, databaser och lagrings konton, distribueras och hanteras. Du kan exempelvis välja att ta bort hela resursgruppen i ett enkelt steg längre fram.

I Cloud Shell skapar du en resursgrupp med az group create kommandot . I följande exempel skapas en resursgrupp med namnet myResourceGroup på platsen Europa, västra. Om du vill se alla platser som stöds för App Service på Linux på Basic-nivån kör du kommandot az appservice list-locations --sku B1 --linux-workers-enabled.

az group create --name myResourceGroup --location "West Europe"

Du skapar vanligtvis din resursgrupp och resurserna i en region nära dig.

När kommandot har slutförts visar JSON-utdata resursgruppens egenskaper.

Skapa En Postgres-databas i Azure

1. Installera db-up tillägget med följande kommando:

   az extension add --name db-up
   

2. Skapa Postgres-databasen i Azure az postgres up med kommandot , som du ser i följande exempel. Ersätt <postgresql-name> med ett unikt namn (serverslutpunkten är https:// <postgresql-name> .postgres.database.azure.com). För <admin-username> och anger du <admin-password> autentiseringsuppgifter för att skapa en administratörsanvändare för den här Postgres-servern.

   az postgres up --resource-group myResourceGroup --location westeurope --server-name <postgresql-name> --database-name sampledb --admin-user <admin-username> --admin-password <admin-password> --ssl-enforcement Enabled
   

   Det här kommandot kan ta en stund eftersom det gör följande:

   • Skapar en resursgrupp med myResourceGroup namnet , om den inte finns. Alla Azure-resurser måste finnas i någon av dessa. --resource-group är valfritt.
   • Skapar en Postgres-server med den administrativa användaren.
   • Skapar en sampledb databas.
   • Tillåter åtkomst från din lokala IP-adress.
   • Tillåter åtkomst från Azure-tjänster.
   • Skapa en databasanvändare med åtkomst till sampledb databasen.

   Du kan göra alla steg separat med andra az postgres kommandon och , men gör alla i ett steg åt psql az postgres up dig.

   När kommandot har avslutats hittar du de utdatarader som är med Ran Database Query: . De visar databasanvändaren som har skapats åt dig med root användarnamnet och lösenordet Sampledb1 . Du kommer att använda dem senare för att ansluta din app till databasen.

   Tips

   --location <location-name>, kan anges till vilken som helst av Azure-regionerna. Du kan hämta de regioner som är tillgängliga för din prenumeration med az account list-locations kommandot . För produktionsappar ska du placera din databas och din app på samma plats.

Anslut appen till Azure Postgres

I det här steget ansluter du Ruby on Rails-appen till Postgres-databasen du skapade i Azure Database för PostgreSQL.

Konfigurera databasanslutningen

På lagringsplatsen öppnar du config/database.yml. Ersätt produktionsvariablerna med följande kod längst ned i filen.

production:
  <<: *default
  host: <%= ENV['DB_HOST'] %>
  database: <%= ENV['DB_DATABASE'] %>
  username: <%= ENV['DB_USERNAME'] %>
  password: <%= ENV['DB_PASSWORD'] %>

Spara ändringarna.

Testa appen lokalt

1. Tillbaka i den lokala terminalen anger du följande miljövariabler:

   export DB_HOST=<postgres-server-name>.postgres.database.azure.com
   export DB_DATABASE=sampledb 
   export DB_USERNAME=root@<postgres-server-name>
   export DB_PASSWORD=Sampledb1
   

2. Kör Rails-databasmigreringar med de produktionsvärden du just konfigurerade för att skapa tabellerna i din Postgres-databas i Azure Database for PostgreSQL.

   rake db:migrate RAILS_ENV=production
   

3. När Rails-programmet körs i produktionsmiljön behöver det förkompilerade tillgångar. Generera de tillgångar som krävs med följande kommando:

   rake assets:precompile
   

4. Rails-produktionsmiljön använder också hemligheter för att hantera säkerhet. Generera en hemlig nyckel.

   rails secret
   

5. Spara den hemliga nyckeln för respektive variabler som används av Rails-produktionsmiljön. För enkelhetens skull använder du samma nyckel för de båda variablerna.

   export RAILS_MASTER_KEY=<output-of-rails-secret>
   export SECRET_KEY_BASE=<output-of-rails-secret>
   

6. Aktivera Rails-produktionsmiljön för att hantera JavaScript- och CSS-filer.

   export RAILS_SERVE_STATIC_FILES=true
   

7. Kör exempelprogrammet i produktionsmiljön.

   rails server -e production
   

8. Navigera till http://localhost:3000. Om sidan läses in utan fel ansluter Ruby on Rails-appen till Postgres-databasen i Azure.

9. Lägg till några uppgifter på sidan.

   

10. Om du vill stoppa Rails-servern skriver du Ctrl + C i terminalen.

Genomföra ändringarna

1. Kör följande Git-kommandon för att genomföra ändringarna:

   git add .
   git commit -m "database.yml updates"
   

Din app är klar att distribuera.

Distribuera till Azure

I det här steget, distribuerar du ditt Postgres-anslutna Rails-program till Azure App Service.

Konfigurera en distributionsanvändare

FTP och lokal Git kan distribuera till en Azure-webbapp med hjälp av en distributionsanvändare. När du har konfigurerat distributionsanvändaren kan du använda den för alla dina Azure-distributioner. Ditt användarnamn och lösenord för distribution på kontonivå skiljer sig från autentiseringsuppgifterna för din Azure-prenumeration.

Konfigurera distributionsanvändaren genom att köra kommandot az webapp deployment user set i Azure Cloud Shell. Ersätt <username> och med ett användarnamn och lösenord för <password> distributionsanvändaren.

• Användarnamnet måste vara unikt i Azure och för lokala Git-pushar får det inte innehålla @ symbolen .
• Lösenordet måste vara minst åtta tecken långt, med två av följande tre element: bokstäver, siffror och symboler.

az webapp deployment user set --user-name <username> --password <password>

JSON-utdata visar lösenordet som null . Om du ser felet 'Conflict'. Details: 409 ska du byta användarnamn. Om du ser felet 'Bad Request'. Details: 400 ska du använda ett starkare lösenord.

Registrera ditt användarnamn och lösenord som ska användas för att distribuera dina webbappar.

Skapa en App Service-plan

I Cloud Shell skapar du en App Service plan med az appservice plan create kommandot .

I följande exempel skapas en App Service-plan med namnet myAppServicePlan på prisnivån Kostnadsfri:

az appservice plan create --name myAppServicePlan --resource-group myResourceGroup --sku FREE --is-linux

När App Service-planen har skapats visas information av Azure CLI. Informationen ser ut ungefär som i följande exempel:

{ 
  "freeOfferExpirationTime": null,
  "geoRegion": "West Europe",
  "hostingEnvironmentProfile": null,
  "id": "/subscriptions/0000-0000/resourceGroups/myResourceGroup/providers/Microsoft.Web/serverfarms/myAppServicePlan",
  "kind": "linux",
  "location": "West Europe",
  "maximumNumberOfWorkers": 1,
  "name": "myAppServicePlan",
  < JSON data removed for brevity. >
  "targetWorkerSizeId": 0,
  "type": "Microsoft.Web/serverfarms",
  "workerTierName": null
} 

Skapa en webbapp

Skapa en webbapp i myAppServicePlan App Service plan.

I Cloud Shell kan du använda az webapp create kommandot . Ersätt <app-name> med ett globalt unikt appnamn (giltiga tecken är a-z, 0-9 och -) i följande exempel. Körningen har angetts till RUBY|2.6.2. Om du vill se alla körningar som stöds kör du az webapp list-runtimes --linux .

az webapp create --resource-group myResourceGroup --plan myAppServicePlan --name <app-name> --runtime 'RUBY|2.6.2' --deployment-local-git

När webbappen har skapats visar Azure CLI utdata liknande den i följande exempel:

Local git is configured with url of 'https://<username>@<app-name>.scm.azurewebsites.net/<app-name>.git'
{
  "availabilityState": "Normal",
  "clientAffinityEnabled": true,
  "clientCertEnabled": false,
  "cloningInfo": null,
  "containerSize": 0,
  "dailyMemoryTimeQuota": 0,
  "defaultHostName": "<app-name>.azurewebsites.net",
  "deploymentLocalGitUrl": "https://<username>@<app-name>.scm.azurewebsites.net/<app-name>.git",
  "enabled": true,
  < JSON data removed for brevity. >
}

Du har skapat en tom ny webbapp med git-distribution aktiverad.

Konfigurera databasinställningarna

I App Service ställer du in miljövariabler som appinställningar med kommandot az webapp config appsettings set i Cloud Shell.

Följande Cloud Shell-kommando konfigurerar appinställningarna DB_HOST, DB_DATABASE, DB_USERNAME och DB_PASSWORD. Ersätt platshållarna < appname> < och postgres-server-name>.

az webapp config appsettings set --name <app-name> --resource-group myResourceGroup --settings DB_HOST="<postgres-server-name>.postgres.database.azure.com" DB_DATABASE="sampledb" DB_USERNAME="root@<postgres-server-name>" DB_PASSWORD="Sampledb1"

Konfigurera Rails-miljövariabler

1. Generera en ny hemlighet för Rails-produktionsmiljön i Azure i den lokala terminalen.

   rails secret
   

2. I följande Cloud Shell kommando ersätter du platshållarna < output-of-rails-secret> med den nya hemliga nyckeln som du genererade i den lokala terminalen.

   az webapp config appsettings set --name <app-name> --resource-group myResourceGroup --settings RAILS_MASTER_KEY="<output-of-rails-secret>" SECRET_KEY_BASE="<output-of-rails-secret>" RAILS_SERVE_STATIC_FILES="true" ASSETS_PRECOMPILE="true"
   

   ASSETS_PRECOMPILE="true" uppmanar Ruby-standardcontainern att förkompilera tillgångar vid varje Git-distribution. Mer information finns i Förkompilera tillgångar och Betjäna statiska tillgångar.

Skicka till Azure från Git

1. Eftersom du distribuerar -grenen måste du ange standarddistributionsgrenen för din main App Service-app main till (se Ändra distributionsgren). I Cloud Shell anger du DEPLOYMENT_BRANCH appinställningen med az webapp config appsettings set kommandot .

   az webapp config appsettings set --name <app-name> --resource-group myResourceGroup --settings DEPLOYMENT_BRANCH='main'
   

2. I den lokala terminalen kan du lägga till en Azure-fjärrdatabas till din lokala Git-databas.

   git remote add azure <paste-copied-url-here>
   

3. Skicka till Azure-fjärrdatabasen för att distribuera Ruby on Rails-appen. Du uppmanas att ange lösenordet du angav tidigare. Det behövs för att skapa distributionsanvändaren.

   git push azure main
   

   Under distributionen meddelar Azure App Service förloppet till Git.

    Counting objects: 3, done.
    Delta compression using up to 8 threads.
    Compressing objects: 100% (3/3), done.
    Writing objects: 100% (3/3), 291 bytes | 0 bytes/s, done.
    Total 3 (delta 2), reused 0 (delta 0)
    remote: Updating branch 'main'.
    remote: Updating submodules.
    remote: Preparing deployment for commit id 'a5e076db9c'.
    remote: Running custom deployment command...
    remote: Running deployment command...
    ...
    < Output has been truncated for readability >
    

Bläddra till Azure-appen

Bläddra till http://<app-name>.azurewebsites.net och lägg till några uppgifter i listan.

Grattis! Du kör en datadriven Ruby on Rails-app i Azure App Service.

Uppdatera modell lokalt och distribuera om

I det här steget gör du en enkel ändring i task-datamodellen och webbappen och publicerar sedan uppdateringen till Azure.

För uppgiftsscenariot ändrar du programmet så att du kan markera en uppgift som slutförd.

Lägga till en kolumn

1. I terminalen går du till roten för Git-lagringsplatsen.

2. Generera en ny migrering som lägger till en boolesk kolumn med namnet Done i tabellen Tasks:

   rails generate migration AddDoneToTasks Done:boolean
   

   Det här kommandot genererar en ny migrationsfil i katalogen db/migrate.

3. I terminalen kör du Rails-databasemigreringar för att göra ändringen i den lokala databasen.

   rake db:migrate
   

Uppdatera programlogik

1. Öppna filen app/controllers/tasks_controller.rb. Lägg till följande rad i slutet av filen:

   params.require(:task).permit(:Description)
   

2. Ändra raden så att den inkluderar den nya parametern Done.

   params.require(:task).permit(:Description, :Done)
   

Uppdatera vyerna

1. Öppna filen app/views/tasks/_form.html.erb, som är i redigeringsform.

2. Leta reda på raden <%=f.error_span(:Description) %> och infoga följande kod direkt under den:

   <%= f.label :Done, :class => 'control-label col-lg-2' %>
   <div class="col-lg-10">
     <%= f.check_box :Done, :class => 'form-control' %>
   </div>
   

3. Öppna filen app/views/tasks/show.html.erb, som är den enskilda postens visningssida.

   Leta reda på raden <dd><%= @task.Description %></dd> och infoga följande kod direkt under den:

     <dt><strong><%= model_class.human_attribute_name(:Done) %>:</strong></dt>
     <dd><%= check_box "task", "Done", {:checked => @task.Done, :disabled => true}%></dd>
   

   Öppna filen app/views/tasks/index.html.erb, som är indexsidan för alla poster.

   Leta reda på raden <th><%= model_class.human_attribute_name(:Description) %></th> och infoga följande kod direkt under den:

   <th><%= model_class.human_attribute_name(:Done) %></th>
   

4. I samma fil letar du reda på raden <td><%= task.Description %></td> och infogar följande kod direkt under den:

   <td><%= check_box "task", "Done", {:checked => task.Done, :disabled => true} %></td>
   

Testa ändringarna lokalt

1. Kör Rails-servern i den lokala terminalen.

   rails server
   

2. Om du vill se ändringen i uppgiftsstatusen går du till http://localhost:3000 och lägger till eller redigerar objekt.

   

3. Om du vill stoppa Rails-servern skriver du Ctrl + C i terminalen.

Publicera ändringar till Azure

1. I terminalen kör du Rails-databasmigreringar för produktionsmiljön för att genomföra ändringen i Azure-databasen.

   rake db:migrate RAILS_ENV=production
   

2. Genomför alla ändringar på Git och skicka sedan kodändringarna till Azure.

   git add .
   git commit -m "added complete checkbox"
   git push azure main
   

3. När git push har slutförts så kan du gå till Azure-appen och prova de nya funktionerna.

   

   Om du har lagt till några uppgifter finns de kvar i databasen. Uppdateringar i dataschemat påverkar inte befintliga data.

Strömma diagnostikloggar

Om du vill komma åt konsolloggarna som genereras i din programkod i App Service aktiverar du diagnostisk loggning genom att köra följande kommando i Cloud Shell:

az webapp log config --resource-group <resource-group-name> --name <app-name> --docker-container-logging filesystem --level Verbose

Möjliga värden för --level är: Error, Warning, Info och Verbose. Varje efterföljande nivå omfattar den föregående nivån. Exempel: Error omfattar endast felmeddelanden och Verbose omfattar alla meddelanden.

När diagnostisk loggning har aktiverats kör du följande kommando för att visa loggströmmen:

az webapp log tail --resource-group <resource-group-name> --name <app-name>

Om du inte ser konsolloggarna omedelbart kan du titta efter igen efter 30 sekunder.

Skriv Ctrl+C när som helst för att stoppa loggströmningen.

Hantera Azure-appen

1. Gå till Azure-portalen för att hantera den app som du skapade.

2. I den vänstra menyn, klickar du på App Services och därefter på namnet på din Azure-app.

   

   Nu visas översiktssidan för din app. Här kan du utföra grundläggande hanteringsåtgärder som att stoppa, starta, starta om, bläddra och ta bort.

   Menyn till vänster innehåller sidor för att konfigurera appen.

   

Rensa resurser

I de föregående stegen skapade du Azure-resurser i en resursgrupp. Om du inte tror att du behöver dessa resurser i framtiden tar du bort resursgruppen genom att köra följande kommando i Cloud Shell:

az group delete --name myResourceGroup

Det kan några minuter att köra kommandot.

Nästa steg

I den här självstudiekursen lärde du dig att:

Gå vidare till nästa självstudie där du får lära dig att mappa ett anpassat DNS-namn till appen.

Eller så kan du kolla in andra resurser: