Oktatóanyag: Buildelés és üzembe helyezés forráskódból az Azure Container Appsbe

Ez a cikk bemutatja, hogyan hozhat létre és helyezhet üzembe alkalmazásokat az Azure Container Appsben a számítógépen található forráskódból az ön által előnyben részesített programozási nyelven.

Ebben az oktatóanyagban a következőket fogja elkönyvelni:

Hozzon létre egy egyszerű webalkalmazást.
Hozzon létre egy társított Dockerfile-fájlt az alkalmazáshoz.
Hozzon létre egy képet a lefordított kódból, és küldje el egy tárolóregisztrációs adatbázisba.
Felügyelt identitással biztonságosan elérheti a tárolóregisztrációs adatbázist.
Helyezze üzembe a tárolót az Azure Container Appsben.
Tekintse meg az alkalmazást egy böngészőben az üzembe helyezés ellenőrzéséhez.

Előfeltételek

A projekt végrehajtásához a következő elemekre van szüksége:

Követelmény	Utasítások
Azure-fiók	Ha nem rendelkezik ilyen fiókkal, hozzon létre ingyenes fiókot. A folytatáshoz az Azure-előfizetés közreműködői vagy tulajdonosi engedélyére van szüksége. Részletekért tekintse meg az Azure-szerepkörök hozzárendelését az Azure Portalon .
Azure CLI	Telepítse az Azure CLI-t , vagy frissítsen a legújabb verzióra. Az Azure Developer CLI (`azd` parancsok) az Azure CLI-n keresztül érhetők el.

A választott nyelvtől függően előfordulhat, hogy telepítenie kell a megfelelő futtatókörnyezetet, az SDK-t és más függőségeket is.

Telepítse a .NET SDK-t.

A helyi alkalmazás létrehozása

Az alábbi lépések az Azure Container Appsben üzembe helyezendő mintaalkalmazás létrehozásához szükséges kódot és függőségeket mutatják be.

Feljegyzés

Ha a felsoroltaktól eltérő nyelvet szeretne használni, írja be a következő kérdést az előnyben részesített AI-modellbe.

A kérés elküldése előtt cserélje le <LANGUAGE> a kívánt nyelvre.

Generate the simplest possible "hello world" web server in idiomatic <LANGUAGE>.

Make sure to include any dependencies required for the application to run locally and in production.

Hozza létre és futtassa a forráskódot.

Hozzon létre egy új C#-projektet.

dotnet new webapp --name MyAcaDemo --language C#

Váltson a MyAcaDemo mappára.

cd MyAcaDemo

Nyisson meg Program.cs egy kódszerkesztőben, és cserélje le a tartalmat a következő kódra.

public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>();
                webBuilder.UseUrls("http://*:8080");
            });
}

Az osztály ezzel a Program kóddal való implementálása létrehozza egy webalkalmazás alapját. Ezután hozzon létre egy osztályt, amely felelős egy weblap válaszként való visszaadásáért.

Ugyanabban a mappában hozzon létre egy új, elnevezett Startup.cs fájlt, és írja be a következő kódot.

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
    }

    public void Configure(IApplicationBuilder app)
    {   
        app.UseRouting();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapGet("/", async context =>
            {
                await context.Response.WriteAsync("Hello World!");
            });
        });
    }
}

Most, amikor kérést intéz a webalkalmazáshoz, a "„Helló világ!” alkalmazás!" szöveg lesz visszaadva. Ha ellenőrizni szeretné, hogy a kód megfelelően fut-e a helyi gépen, hozza létre a projektet a kiadási konfigurációban.

dotnet build -c Release

Ezután futtassa az alkalmazást annak ellenőrzéséhez, hogy a kód megfelelően van-e implementálva.

dotnet run --configuration Release

Hozzon létre egy új Java-alkalmazást a Spring Boot kezdőalkalmazás lekérésével az alábbi paranccsal.

curl https://start.spring.io/starter.zip -d dependencies=web -d name=MyAcaDemo -d artifactId=MyAcaDemo -d baseDir=MyAcaDemo -o MyAcaDemo.zip

Ha nincs telepítve a unzip parancs, most már telepítheti.

sudo apt-get update && sudo apt-get install unzip

Most már kibonthatja a csomagot egy MyAcaDemo nevű mappába.

unzip MyAcaDemo.zip -d MyAcaDemo

A csomag kibontásakor létrehoz egy beágyazott mappastruktúrát, amelyben a MyAcaDemo nevű mappa egy MyAcaDemo nevű külső mappában található.

A következő paranccsal váltson a megfelelő MyAcaDemo mappára.

cd MyAcaDemo/MyAcaDemo

Nyissa meg ezt a mappát egy kódszerkesztőben, hogy fájlokat vegyen fel és szerkesszen.

src/main/java/com/example/MyAcaDemo/ A mappában hozzon létre egy nevű MyAcaDemoController.java fájlt, és írja be a következő kódot.

package com.example.MyAcaDemo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyAcaDemoController {
    @GetMapping("/")
    public String hello() {
        return "Hello, World!";
    }
}

A MyAcaDemo mappában hozzon létre egy nevű pom.xml fájlt, és adja hozzá a következő kódot.

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>MyAcaDemo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>MyAcaDemo</name>
    <description>Demo project for Spring Boot</description>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>3.1.0</version>
            <configuration>
                <mainClass>com.example.MyAcaDemo.MyAcaDemoApplication</mainClass>
            </configuration>
        </plugin>
        </plugins>
    </build>
</project>

Futtassa a következő parancsot a projekt buildjeinek hibák nélküli ellenőrzéséhez.

mvn clean package -DskipTests

Sikeres buildelés után futtassa a következő parancsot, hogy az alkalmazás megfelelően fusson a számítógépen.

mvn spring-boot:run

Hozzon létre egy MyAcaDemo nevű mappát a bemutató alkalmazás fájljainak tárolásához.

mkdir MyAcaDemo

Ezután váltson a MyAcaDemo mappára.

cd MyAcaDemo

Az alábbi paranccsal hozhatja létre az Node.js-alkalmazások alapfájljait.

npm init -y

Nyissa meg ezt a mappát egy kódszerkesztőben, és hozzon létre egy fájlt index.js az alábbi kóddal.

const http = require('http');

const server = http.createServer((req, res) => {
    res.writeHead(200, { 'Content-Type': 'text/html' });
    res.end('<html>Hello World!</html>');
});

server.listen(8080, () => {
    console.log('Server running at http://localhost:8080/');
});

Most futtathatja a következő parancsot, hogy az alkalmazás megfelelően fusson a számítógépen.

node index.js

Hozzon létre egy MyAcaDemo nevű mappát.

mkdir MyAcaDemo

Váltson a MyAcaDemo mappára.

cd MyAcaDemo

Telepítse a Flaskot a következő paranccsal.

pip install flask

A mintaalkalmazás a Flask-keretrendszeren alapul. Helyileg kell telepítenie, hogy ellenőrizze, hogy az alkalmazás megfelelően fut-e a gépen, mielőtt megpróbálná üzembe helyezni a felhőben.

Hozzon létre egy új, elnevezett app.py fájlt, és írja be a következő kódot.

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return '<html>Hello World!</html>'

if __name__ == '__main__':
    app.run()

Ez a kód létrehoz egy alapszintű webkiszolgálót, amely „Helló világ!” alkalmazás!.

Ugyanabban a mappában hozzon létre egy új, elnevezett requirements.txt fájlt, és írja be a következő kódot.

Flask
gunicorn

Ez a fájl arra utasítja a Python-futtatókörnyezetet, hogy a Flask webes keretrendszert és a gunicorn webkiszolgálót használja a mintaalkalmazás üzemeltetéséhez.

Futtassa a következő parancsot az alkalmazás megfelelő működésének ellenőrzéséhez.

python3 app.py

Miután ellenőrizte, hogy az alkalmazás a várt módon működik-e, leállíthatja a helyi kiszolgálót, és továbbléphet egy Docker-fájl létrehozására, hogy üzembe helyezhesse az alkalmazást a Container Appsben.

A MyAcaDemo mappában hozzon létre egy nevű Dockerfile fájlt, és adja hozzá a következő tartalmat.

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY . .
RUN dotnet publish -c Release -o /app/publish

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS final
WORKDIR /app
COPY --from=build /app/publish .
EXPOSE 8080
ENTRYPOINT ["dotnet", "MyAcaDemo.dll"]

FROM maven:3.8.4-openjdk-17 AS build
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN mvn clean package -DskipTests

FROM openjdk:17-jdk-alpine
WORKDIR /app
COPY --from=build /app/target/MyAcaDemo-0.0.1-SNAPSHOT.jar /app/MyAcaDemo.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "MyAcaDemo.jar"]

FROM node:18
WORKDIR /usr/src/app
COPY ./ . 
RUN npm install
EXPOSE 3000
CMD ["node", "index.js"]

FROM python:3.9-slim
WORKDIR /app
COPY . /app
RUN pip install --no-cache-dir -r requirements.txt
EXPOSE 8080
ENV FLASK_APP=app.py
CMD ["gunicorn", "--bind", "0.0.0.0:8080", "app:app"]

Most, hogy elkészült a kód és a Dockerfile, üzembe helyezheti az alkalmazást az Azure Container Appsben.

Azure-erőforrások létrehozása

Jelentkezzen be az Azure-ba a parancssori felületről a következő paranccsal. A hitelesítési folyamat befejezéséhez mindenképpen kövesse az összes kérést.
```
az login
```
Telepítse vagy frissítse az Azure Cli Azure Container Apps-bővítményét.
```
az extension add --name containerapp --upgrade
```
Feljegyzés

Ha a parancsok futtatásakor az containerapp hibaüzenetet kap a hiányzó paraméterekről, győződjön meg arról, hogy telepítve van az Azure Container Apps bővítmény legújabb verziója.
Most, hogy az Azure CLI beállítása befejeződött, definiálhat környezeti változókat.

A következő parancs futtatása előtt tekintse át a megadott értékeket.

A hely az USA középső régiójaként van konfigurálva, de tetszés szerint az Önhöz legközelebbi helyre válthat.
```
LOCATION="CentralUS"
RESOURCE_GROUP="my-demo-group"
IDENTITY_NAME="my-demo-identity"
ENVIRONMENT="my-demo-environment"
REGISTRY_NAME="mydemoregistry$(openssl rand -hex 4)"
CONTAINER_APP_NAME="my-demo-app"
```
A mydemoregistry$(openssl rand -hex 4) parancs létrehoz egy véletlenszerű sztringet a tárolóregisztrációs adatbázis neveként. A beállításjegyzék nevének globálisan egyedinek kell lennie, ezért ez a sztring segít a parancsok sikeres futtatásában.
Hozzon létre egy erőforráscsoportot a tárolóalkalmazás üzembe helyezéséhez kapcsolódó szolgáltatások rendszerezéséhez.
```
az group create \
  --name $RESOURCE_GROUP \
  --location $LOCATION \
  --output none
```
Hozzon létre egy felhasználó által hozzárendelt felügyelt identitást , és kérje le az azonosítóját az alábbi parancsokkal.

Először hozza létre a felügyelt identitást.
```
az identity create \
    --name $IDENTITY_NAME \
    --resource-group $RESOURCE_GROUP \
    --output none
```
Most állítsa be az identitásazonosítót egy változóra későbbi használatra.
```
IDENTITY_ID=$(az identity show \
  --name $IDENTITY_NAME \
  --resource-group $RESOURCE_GROUP \
  --query id \
  --output tsv)
```

Hozzon létre egy Container Apps-környezetet az alkalmazás üzemeltetéséhez az alábbi paranccsal.

az containerapp env create \
    --name $ENVIRONMENT \
    --resource-group $RESOURCE_GROUP \
    --location $LOCATION \
    --mi-user-assigned $IDENTITY_ID \
    --output none

Hozzon létre egy Azure Container Registry-példányt (ACR) az erőforráscsoportban. A beállításjegyzék tárolja a tárolórendszerképet.
```
az acr create \
  --resource-group $RESOURCE_GROUP \
  --name $REGISTRY_NAME \
  --sku Basic \
  --output none
```
Rendelje hozzá a felhasználó által hozzárendelt felügyelt identitást a tárolóregisztrációs adatbázispéldányhoz az alábbi paranccsal.
```
az acr identity assign \
  --identities $IDENTITY_ID \
  --name $REGISTRY_NAME \
  --resource-group $RESOURCE_GROUP \
  --output none
```

A rendszerkép létrehozása és leküldése egy beállításjegyzékbe

Hozza létre és küldje le a tárolórendszerképet a tárolóregisztrációs adatbázispéldányba az alábbi paranccsal.

az acr build \
    -t $REGISTRY_NAME".azurecr.io/"$CONTAINER_APP_NAME":helloworld" \
    -r $REGISTRY_NAME .

Ez a parancs a címkét helloworld alkalmazza a tárolórendszerképre.

Tárolóalkalmazás létrehozása

Hozza létre a tárolóalkalmazást a következő paranccsal.

az containerapp create \
  --name $CONTAINER_APP_NAME \
  --resource-group $RESOURCE_GROUP \
  --environment $ENVIRONMENT \
  --image $REGISTRY_NAME".azurecr.io/"$CONTAINER_APP_NAME":helloworld" \
  --target-port 8080 \
  --ingress external \
  --user-assigned $IDENTITY_ID \
  --registry-identity $IDENTITY_ID \
  --registry-server $REGISTRY_NAME.azurecr.io \
  --query properties.configuration.ingress.fqdn

Ez a parancs hozzáadja a szerepkört a acrPull felhasználó által hozzárendelt felügyelt identitáshoz, így lekérheti a lemezképeket a tárolóregisztrációs adatbázisból.

Az alábbi táblázat a parancs által használt paramétereket ismerteti.

Paraméter	Érték	Leírás
`name`	`$CONTAINER_APP_NAME`	A tárolóalkalmazás neve.
`resource-group`	`$RESOURCE_GROUP`	Az az erőforráscsoport, amelyben a tárolóalkalmazás üzembe van helyezve.
`environment`	`$ENVIRONMENT`	A környezet, amelyben a tárolóalkalmazás fut.
`image`	`$REGISTRY_NAME".azurecr.io/"$CONTAINER_APP_NAME":helloworld"`	Az üzembe helyezendő tárolórendszerkép, beleértve a beállításjegyzék nevét és címkéjét.
`target-port`	`8080`	Megfelel annak a portnak, amelyet az alkalmazás a kérelmeket figyel.
`ingress`	`external`	A tárolóalkalmazást elérhetővé teszi a nyilvános internetről.
`user-assigned`	`$IDENTITY_ID`	A tárolóalkalmazás felhasználó által hozzárendelt felügyelt identitása.
`registry-identity`	`registry-identity`	A tárolóregisztrációs adatbázis eléréséhez használt identitás.
`registry-server`	`$REGISTRY_NAME.azurecr.io`	A tárolóregisztrációs adatbázis kiszolgálócíme.
`query`	`properties.configuration.ingress.fqdn`	A kimenetet csak az alkalmazás teljes tartománynevére (FQDN) szűri.

Miután ez a parancs befejeződött, visszaadja az új webalkalmazás URL-címét.

Az üzembe helyezés ellenőrzése

Másolja az alkalmazás URL-címét egy webböngészőbe. A tárolóalkalmazás elindítása után „Helló világ!” alkalmazás!.

Mivel az alkalmazás első alkalommal érhető el, eltarthat néhány percig, amíg az alkalmazás választ ad vissza.

Az erőforrások eltávolítása

Ha nem fogja használni az oktatóanyagban létrehozott Azure-erőforrásokat, egyetlen paranccsal eltávolíthatja őket. A parancs futtatása előtt az oktatóanyag-sorozat egy következő lépése bemutatja, hogyan módosíthatja a kódot, és frissítheti az alkalmazást az Azure-ban.

Ha végzett, és el szeretné távolítani az oktatóanyagban létrehozott összes Azure-erőforrást, törölje az erőforráscsoportot az alábbi paranccsal.

az group delete --name aca-demo

Tipp.

Problémákat tapasztal? Tudassa velünk a GitHubon, ha megnyit egy hibát az Azure Container Apps adattárában.

Következő lépések

A következő lépésben megtudhatja, hogyan frissítheti a létrehozott tárolóalkalmazást.

Forráskódból üzembe helyezett tárolóalkalmazás frissítése

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-02-25