Kubernetes-alkalmazás fejlesztése az Azure SQL Database-hez

  • Cikk

A következőre vonatkozik: Azure SQL Database

Ebben az oktatóanyagban megtudhatja, hogyan fejleszthet modern alkalmazást Python, Docker Containers, Kubernetes és Azure SQL Database használatával.

A modern alkalmazásfejlesztésnek számos kihívása van. Az előtérbeli "verem" kiválasztásától kezdve az adattároláson és a különböző konkurens szabványok feldolgozásán keresztül a legmagasabb szintű biztonság és teljesítmény biztosításán keresztül a fejlesztőknek gondoskodniuk kell arról, hogy az alkalmazás méretezhető és jól teljesít, és több platformon is támogatott legyen. Az utolsó követelmény esetében az alkalmazás tárolótechnológiákba, például a Dockerbe való csatlakoztatása és több tároló üzembe helyezése a Kubernetes platformon most már de rigueur az alkalmazásfejlesztésben.

Ebben a példában a Python, a Docker Containers és a Kubernetes használatával ismerkedünk meg – mind a Microsoft Azure platformon. A Kubernetes használata azt jelenti, hogy rugalmasan használhat helyi környezeteket vagy akár más felhőket is az alkalmazás zökkenőmentes és konzisztens üzembe helyezéséhez, és lehetővé teszi a többfelhős üzembe helyezést a még nagyobb rugalmasság érdekében. A Microsoft Azure SQL Database szolgáltatásalapú, skálázható, rendkívül rugalmas és biztonságos környezethez is használható lesz az adattároláshoz és -feldolgozáshoz. Valójában sok esetben más alkalmazások már gyakran használják a Microsoft Azure SQL Database-t, és ez a mintaalkalmazás használható az adatok további felhasználására és bővítésére.

Ez a példa hatóköre meglehetősen átfogó, de a legegyszerűbb alkalmazást, adatbázist és üzembe helyezést használja a folyamat szemléltetésére. Ezt a mintát sokkal robusztusabbá teheti, még akkor is, ha a legújabb technológiákat használja a visszaadott adatokhoz. Ez egy hasznos tanulási eszköz, amellyel mintát hozhat létre más alkalmazásokhoz.

A Python, a Docker Containers, a Kubernetes és az AdventureWorksLT mintaadatbázis használata gyakorlati példában

Az AdventureWorks (fiktív) vállalat egy olyan adatbázist használ, amely adatokat tárol az értékesítésről és marketingről, a termékekről, az ügyfelekről és a gyártásról. Emellett olyan nézeteket és tárolt eljárásokat is tartalmaz, amelyek összekapcsolják a termékekkel kapcsolatos információkat, például a termék nevét, kategóriáját, árát és rövid leírását.

Az AdventureWorks fejlesztői csapata létre szeretne hozni egy megvalósíthatósági igazolást (PoC), amely adatokat ad vissza az AdventureWorksLT adatbázis nézetéből, és REST API-ként elérhetővé teszi őket. Ezzel a poC-vel a fejlesztői csapat egy méretezhetőbb és többfelhős használatra kész alkalmazást hoz létre az értékesítési csapat számára. A Microsoft Azure platformot választották az üzembe helyezés minden aspektusához. A poC a következő elemeket használja:

  • Egy Python-alkalmazás, amely a Flask-csomagot használja a fej nélküli webes üzembe helyezéshez.
  • Docker-tárolók kód- és környezetelkülönítéshez, privát beállításjegyzékben tárolva, hogy a teljes vállalat újra felhasználhassa az alkalmazástárolókat a jövőbeli projektekben, így időt és pénzt takaríthat meg.
  • A Kubernetes a könnyű üzembe helyezés és a skálázás érdekében, valamint a platformzárolás elkerülése érdekében.
  • Microsoft Azure SQL Database méret, teljesítmény, méretezés, automatikus kezelés és biztonsági mentés kiválasztásához a relációs adattárolás és -feldolgozás mellett a legmagasabb biztonsági szinten.

Ebben a cikkben a teljes megvalósíthatósági projekt létrehozásának folyamatát ismertetjük. Az alkalmazás létrehozásának általános lépései a következők:

  1. Előfeltételek beállítása
  2. Az alkalmazás létrehozása
  3. Docker-tároló létrehozása az alkalmazás üzembe helyezéséhez és teszteléséhez
  4. Azure Container Service (ACS) beállításjegyzék létrehozása és a tároló betöltése az ACS-beállításjegyzékbe
  5. Az Azure Kubernetes Service (AKS) környezetének létrehozása
  6. Az alkalmazástároló üzembe helyezése az ACS-beállításjegyzékből az AKS-be
  7. Az alkalmazás tesztelése
  8. A fölöslegessé vált elemek eltávolítása

Előfeltételek

Ebben a cikkben számos értéket kell lecserélni. Győződjön meg arról, hogy minden lépésnél következetesen lecseréli ezeket az értékeket. Előfordulhat, hogy meg szeretne nyitni egy szövegszerkesztőt, és be szeretné állítani a megfelelő értékeket a megvalósíthatósági ellenőrzés projekt során:

  • ReplaceWith_AzureSubscriptionName: Cserélje le ezt az értéket a meglévő Azure-előfizetés nevére.
  • ReplaceWith_PoCResourceGroupName: Cserélje le ezt az értéket a létrehozni kívánt erőforráscsoport nevére.
  • ReplaceWith_AzureSQLDBServerName: Cserélje le ezt az értéket az Azure Portallal létrehozott Azure SQL Database logikai kiszolgáló nevére.
  • ReplaceWith_AzureSQLDBSQLServerLoginName: Cserélje le ezt az értéket az Azure Portalon létrehozott SQL Server-felhasználónév értékére.
  • ReplaceWith_AzureSQLDBSQLServerLoginPassword: Cserélje le ezt az értéket az Azure Portalon létrehozott SQL Server-felhasználói jelszó értékére.
  • ReplaceWith_AzureSQLDBDatabaseName: Cserélje le ezt az értéket az Azure Portallal létrehozott Azure SQL Database nevére.
  • ReplaceWith_AzureContainerRegistryName: Cserélje le ezt az értéket a létrehozni kívánt Azure Container Registry nevére.
  • ReplaceWith_AzureKubernetesServiceName: Cserélje le ezt az értéket a létrehozni kívánt Azure Kubernetes Service nevére.

Az AdventureWorks fejlesztői Windows, Linux és Apple rendszerek kombinációját használják a fejlesztéshez, ezért a Visual Studio Code-ot használják környezetükként, a gitet pedig a forráskövetéshez, mindkettő platformfüggetlenül fut.

A poC esetében a csapatnak a következő előfeltételekre van szüksége:

  1. Python, pip és csomagok – A fejlesztői csapat a Python programozási nyelvet választja szabványként ehhez a webalapú alkalmazáshoz. Jelenleg a 3.9-es verziót használják, de a PoC-hez szükséges csomagokat támogató bármely verzió elfogadható.

  2. A csapat a pyodbc csomagot adatbázis-hozzáférésre használja.

  3. A csapat a csomagot használja a ConfigParser konfigurációs változók vezérléséhez és beállításához.

  4. A csapat a Flask-csomagot használja az alkalmazás webes felületéhez.

  5. Ezután a csapat telepítette az Azure CLI eszközt, amely könnyen azonosítható szintaxissal az . Ez a platformfüggetlen eszköz lehetővé teszi a poC parancssori és szkriptelt megközelítését, hogy a módosítások és fejlesztések során megismételhesse a lépéseket.

  6. Az Azure CLI beállításával a csapat bejelentkezik az Azure-előfizetésbe, és beállítja a PoC-hoz használt előfizetés nevét. Ezután gondoskodtak arról, hogy az Azure SQL Database-kiszolgáló és az adatbázis elérhető legyen az előfizetés számára:

    az login
az account set --name "ReplaceWith_AzureSubscriptionName"
az sql server list
az sql db list ReplaceWith_AzureSQLDBDatabaseName

  7. A Microsoft Azure-erőforráscsoport egy logikai tároló, amely egy Azure-megoldáshoz kapcsolódó erőforrásokat tartalmaz. Az azonos életciklussal rendelkező erőforrások általában ugyanahhoz az erőforráscsoporthoz lesznek hozzáadva, így könnyen üzembe helyezheti, frissítheti és törölheti őket csoportként. Az erőforráscsoport az erőforrások metaadatait tárolja, és megadhatja az erőforráscsoport helyét.

    Az erőforráscsoportok az Azure Portal vagy az Azure CLI használatával hozhatók létre és kezelhetők. Az alkalmazásokhoz kapcsolódó erőforrások csoportosítására és az éles és nem termelési csoportokra, illetve a kívánt egyéb szervezeti struktúra csoportokra oszthatók.

    Screenshot from the Azure portal showing how to search for and filter for Azure Resource groups.

    Az alábbi kódrészletben láthatja az az erőforráscsoport létrehozásához használt parancsot. A mintánkban az Azure eastusrégióját használjuk.

    az group create --name ReplaceWith_PoCResourceGroupName --location eastus

  8. A fejlesztői csapat létrehoz egy Azure SQL Database-adatbázist, amelyen telepítve van a AdventureWorksLT mintaadatbázis, egy SQL-hitelesítésű bejelentkezés használatával.

    Az AdventureWorks szabványosított a Microsoft SQL Server relációsadatbázis-kezelési rendszerplatformján, és a fejlesztői csapat a helyi telepítés helyett egy felügyelt szolgáltatást szeretne használni az adatbázishoz. Az Azure SQL Database használatával ez a felügyelt szolgáltatás teljesen kódkompatibilis lehet mindenhol, ahol az SQL Server-motort futtatják: a helyszínen, tárolóban, Linuxon vagy Windowson, vagy akár az eszközök internetes hálózatában (IoT) is.

    1. A létrehozás során az Azure Management Portal használatával beállították az alkalmazás tűzfalát a helyi fejlesztőgépre, és módosították az itt látható alapértelmezett beállítást az összes Azure-szolgáltatás engedélyezéséhez, valamint lekérték a kapcsolati hitelesítő adatokat is.

      Screenshot from the Azure portal showing the Create SQL Database page. On the Networking tab, for Connectivity method, the Public endpoint option is selected. The Add current client IP Address option is Yes.

      Ezzel a módszerrel az adatbázis egy másik régióban vagy akár egy másik előfizetésben is elérhető lehet.

    2. A csapat beállított egy SQL-hitelesítésű bejelentkezést a teszteléshez, de ezt a döntést biztonsági felülvizsgálatban fogja újra áttekinteni.

    3. A csapat ugyanazt a PoC-erőforráscsoportot használva használta a poC mintaadatbázisát AdventureWorksLT . Ne aggódjon, az oktatóanyag végén megtisztítjuk az új PoC-erőforráscsoport összes erőforrását.

    4. Az Azure SQL Database üzembe helyezéséhez használhatja az Azure Portalt. Az Azure SQL Database létrehozásakor a További beállítások lapon válassza a Meglévő adatok használata lehetőséget, és válassza a Minta lehetőséget.

      Screenshot from the Azure portal showing the Create SQL Database page. In the Additional settings tab, for the Use existing data option, select Sample.

    5. Végül az új Azure SQL Database Címkék lapján a fejlesztői csapat címkék metaadatait adta meg ehhez az Azure-erőforráshoz, például Tulajdonos vagy ServiceClass vagy WorkloadName.

Az alkalmazás létrehozása

Ezután a fejlesztői csapat létrehozott egy egyszerű Python-alkalmazást, amely kapcsolatot nyit meg az Azure SQL Database-hez, és visszaadja a termékek listáját. Ezt a kódot összetettebb függvények váltják fel, és az alkalmazásmegoldások robusztus, jegyzékalapú megközelítése érdekében a Kubernetes Podokban üzembe helyezett több alkalmazást is tartalmazhatnak éles környezetben.

  1. A csapat létrehozott egy egyszerű szöveges fájlt, amely a kiszolgálókapcsolatok és egyéb információk változóinak tárolására szolgál .env . A python-dotenv kódtár használatával ezután elkülöníthetik a változókat a Python Code-tól. Ez egy gyakori módszer a titkos kódok és egyéb információk kódból való kivételével.

    SQL_SERVER_ENDPOINT = ReplaceWith_AzureSQLDBServerName
SQL_SERVER_USERNAME = ReplaceWith_AzureSQLDBSQLServerLoginName
SQL_SERVER_PASSWORD = ReplaceWith_AzureSQLDBSQLServerLoginPassword
SQL_SERVER_DATABASE = ReplaceWith_AzureSQLDBDatabaseName

    Figyelem

    Az egyértelműség és az egyszerűség kedvéért ez az alkalmazás egy Pythonból beolvasott konfigurációs fájlt használ. Mivel a kód a tárolóval együtt lesz üzembe helyezve, lehetséges, hogy a kapcsolati információk a tartalomból származnak. Alaposan át kell gondolnia a biztonság, a kapcsolatok és a titkos kódok használatának különböző módszereit, és meg kell határoznia az alkalmazáshoz használni kívánt legjobb szintet és mechanizmust. Mindig válassza ki a legmagasabb szintű biztonságot, és akár több szintet is, hogy az alkalmazás biztonságos legyen. A titkos adatok, például a kapcsolati sztring és hasonlók többféle módon is használhatóak, és az alábbi lista néhány ilyen lehetőséget mutat.

    További információ: Azure SQL Database security.

  2. A csapat ezután megírta a PoC alkalmazást, és meghívta.app.py

    A következő szkript a következő lépéseket hajtja végre:

    1. Állítsa be a kódtárakat a konfigurációhoz és az alap webes felületekhez.
    2. Töltse be a változókat a .env fájlból.
    3. Hozza létre a Flask-RESTful alkalmazást.
    4. Az Azure SQL Database kapcsolati adatainak lekérése a config.ini fájlértékekkel.
    5. Hozzon létre kapcsolatot az Azure SQL Database-hez a config.ini fájlértékek használatával.
    6. Csatlakozás az Azure SQL Database-be a pyodbc csomag használatával.
    7. Hozza létre az SQL-lekérdezést az adatbázison való futtatáshoz.
    8. Hozza létre azt az osztályt, amely az API-ból származó adatok visszaadására szolgál.
    9. Állítsa az API-végpontot az osztályra Products .
    10. Végül indítsa el az alkalmazást az alapértelmezett Flask 5000-es porton.
    # Set up the libraries for the configuration and base web interfaces
from dotenv import load_dotenv
from flask import Flask
from flask_restful import Resource, Api
import pyodbc

# Load the variables from the .env file
load_dotenv()

# Create the Flask-RESTful Application
app = Flask(__name__)
api = Api(app)

# Get to Azure SQL Database connection information using the config.ini file values
server_name = os.getenv('SQL_SERVER_ENDPOINT')
database_name = os.getenv('SQL_SERVER_DATABASE')
user_name = os.getenv('SQL_SERVER_USERNAME')
password = os.getenv('SQL_SERVER_PASSWORD')

# Create connection to Azure SQL Database using the config.ini file values
ServerName = config.get('Connection', 'SQL_SERVER_ENDPOINT')
DatabaseName = config.get('Connection', 'SQL_SERVER_DATABASE')
UserName = config.get('Connection', 'SQL_SERVER_USERNAME')
PasswordValue = config.get('Connection', 'SQL_SERVER_PASSWORD')

# Connect to Azure SQL Database using the pyodbc package
# Note: You may need to install the ODBC driver if it is not already there. You can find that at:
# https://learn.microsoft.com/sql/connect/odbc/download-odbc-driver-for-sql-server
connection = pyodbc.connect(f'Driver=ODBC Driver 17 for SQL Server;Server={ServerName};Database={DatabaseName};uid={UserName};pwd={PasswordValue}')

# Create the SQL query to run against the database
def query_db():
    cursor = connection.cursor()
    cursor.execute("SELECT TOP (10) [ProductID], [Name], [Description] FROM [SalesLT].[vProductAndDescription] WHERE Culture = 'EN' FOR JSON AUTO;")
    result = cursor.fetchone()
    cursor.close()
    return result

# Create the class that will be used to return the data from the API
class Products(Resource):
    def get(self):
        result = query_db()
        json_result = {} if (result == None) else json.loads(result[0])     
        return json_result, 200

# Set the API endpoint to the Products class
api.add_resource(Products, '/products')

# Start App on default Flask port 5000
if __name__ == "__main__":
    app.run(debug=True)

  3. Ellenőrizték, hogy az alkalmazás helyileg fut-e, és egy lapot ad vissza.http://localhost:5000/products

    Screenshot from a web browser of the Flask return page.

    Fontos

    Éles alkalmazások létrehozásakor ne használja a rendszergazdai fiókot az adatbázis eléréséhez. További információkért olvassa el , hogyan állíthat be fiókot az alkalmazáshoz. A cikkben szereplő kód egyszerűbb, így gyorsan elkezdheti a Pythont és a Kubernetes-t használó alkalmazásokat az Azure-ban.

    Reálisabban használhat egy csak olvasható engedélyekkel rendelkező, tartalmazott adatbázis-felhasználót, vagy egy felhasználó által hozzárendelt felügyelt identitáshoz csatlakoztatott bejelentkezési vagy tárolt adatbázis-felhasználót írásvédett engedélyekkel.

    További információkért tekintse át az API Pythonnal és Azure SQL Database-sel való létrehozásának teljes példáját.

Az alkalmazás üzembe helyezése Docker-tárolóban

A tároló egy fenntartott, védett terület egy számítástechnikai rendszerben, amely elkülönítést és beágyazást biztosít. Tároló létrehozásához használjon jegyzékfájlt, amely egyszerűen egy szöveges fájl, amely leírja a tartalmazni kívánt bináris fájlokat és kódot. Tároló futtatókörnyezet (például Docker) használatával létrehozhat egy bináris rendszerképet, amely tartalmazza a futtatni kívánt összes fájlt, és amelyekre hivatkozni szeretne. Innen "futtathatja" a bináris rendszerképet, amelyet tárolónak nevezünk, amelyre úgy hivatkozhat, mintha teljes számítástechnikai rendszer lenne. Ez egy kisebb, egyszerűbb módszer az alkalmazás futtatókörnyezetének és környezetének absztrakciójára, mint egy teljes virtuális gép használata. További információ: Tárolók és Docker.

A csapat egy DockerFile -val (a jegyzékfájllal) kezdte, amely a csapat által használni kívánt elemeket rétegzi. Először egy alapSzintű Python-lemezképet használnak, amelyen már telepítve vannak a pyodbc kódtárak, majd az összes parancsot futtatják, amely ahhoz szükséges, hogy az előző lépésben tartalmazza a programot és a konfigurációs fájlt.

A következő Dockerfile a következő lépéseket tartalmazza:

  1. Kezdje egy olyan tároló bináris fájllal, amely már rendelkezik Pythonnal, és pyodbc telepítve van.
  2. Hozzon létre egy munkakönyvtárat az alkalmazáshoz.
  3. Másolja az összes kódot az aktuális könyvtárból a WORKDIR.
  4. Telepítse a szükséges kódtárakat.
  5. A tároló elindítása után futtassa az alkalmazást, és nyissa meg az összes TCP/IP-portot.
# syntax=docker/dockerfile:1

# Start with a Container binary that already has Python and pyodbc installed
FROM laudio/pyodbc

# Create a Working directory for the application
WORKDIR /flask2sql

# Copy all of the code from the current directory into the WORKDIR
COPY . .

# Install the libraries that are required
RUN pip install -r ./requirements.txt

# Once the container starts, run the application, and open all TCP/IP ports 
CMD ["python3", "-m" , "flask", "run", "--host=0.0.0.0"]

A fájl helyén a csapat egy parancssorba esett a kódolási könyvtárban, és a következő kódot futtatva létrehozta a bináris rendszerképet a jegyzékből, majd egy másik parancsot a tároló elindításához:

docker build -t flask2sql .
docker run -d -p 5000:5000 -t flask2sql

A csapat ismét teszteli a http://localhost:5000/products hivatkozást, hogy a tároló hozzáférhessen az adatbázishoz, és a következő visszatérés jelenik meg:

Screenshot from a web browser of the Flask return page from the Container.

A rendszerkép üzembe helyezése Docker-beállításjegyzékben

A tároló már működik, de csak a fejlesztő gépén érhető el. A fejlesztői csapat elérhetővé szeretné tenni ezt az alkalmazásképet a vállalat többi tagja számára, majd a Kubernetes számára az éles üzembe helyezéshez.

A Tárolólemezképek tárolóterületét adattárnak nevezzük, és a tárolólemezképek nyilvános és privát adattárai is lehetnek. Az AdvenureWorks valójában nyilvános rendszerképet használt a Python-környezethez a Dockerfile-ban.

A csapat szeretné szabályozni a rendszerképhez való hozzáférést, és ahelyett, hogy a weben helyezné el, úgy döntenek, hogy saját maguk szeretnék üzemeltetni, hanem a Microsoft Azure-ban, ahol teljes mértékben szabályozhatják a biztonságot és a hozzáférést. A Microsoft Azure Container Registryről itt olvashat bővebben.

A parancssorba visszatérve a fejlesztői csapat egy tárolóregisztrációs szolgáltatás hozzáadását, egy felügyeleti fiók engedélyezését, névtelen "lekérések" beállítását használja az CLI a tesztelési fázisban, és beállít egy bejelentkezési környezetet a beállításjegyzékben:

az acr create --resource-group ReplaceWith_PoCResourceGroupName --name ReplaceWith_AzureContainerRegistryName --sku Standard
az acr update -n ReplaceWith_AzureContainerRegistryName --admin-enabled true
az acr update --name ReplaceWith_AzureContainerRegistryName --anonymous-pull-enabled
az acr login --name ReplaceWith_AzureContainerRegistryName

Ezt a környezetet a rendszer a következő lépésekben fogja használni.

A helyi Docker-rendszerkép címkézése a feltöltés előkészítéséhez

A következő lépés a helyi alkalmazás tárolórendszerképének elküldése az Azure Container Registry (ACR) szolgáltatásnak, hogy az elérhető legyen a felhőben.

  1. A következő példaszkriptben a csapat a Docker-parancsokkal listázhatja a képeket a gépen.
  2. A segédprogrammal az CLI listázzák a képeket az ACR szolgáltatásban.
  3. A Docker paranccsal "címkézik" a képet az előző lépésben létrehozott ACR célnevével, és beállítanak egy verziószámot a megfelelő DevOpshoz.
  4. Végül ismét listázzák a helyi rendszerkép adatait, hogy a címke megfelelően legyen alkalmazva.
docker images
az acr list --resource-group ReplaceWith_PoCResourceGroupName --query "[].{acrLoginServer:loginServer}" --output table
docker tag flask2sql ReplaceWith_AzureContainerRegistryName.azurecr.io/azure-flask2sql:v1
docker images

A megírt és tesztelt kód, a Dockerfile, a rendszerkép és a tároló futtatása és tesztelése, az ACR szolgáltatás beállítása és az összes alkalmazott címke használatával a csapat feltöltheti a képet az ACR szolgáltatásba.

A docker "push" paranccsal küldik el a fájlt, majd a az CLI segédprogrammal biztosítják a rendszerkép betöltését:

docker push ReplaceWith_AzureContainerRegistryName.azurecr.io/azure-flask2sql:v1
az acr repository list --name ReplaceWith_AzureContainerRegistryName --output table

Deploy to Kubernetes

A csapat egyszerűen futtathat tárolókat, és üzembe helyezheti az alkalmazást helyszíni és felhőbeli környezetekben. Szeretnék azonban az alkalmazás több példányát hozzáadni a skálázáshoz és a rendelkezésre álláshoz, más, különböző feladatokat végző tárolókat hozzáadni, valamint monitorozást és rendszerezést hozzáadni a teljes megoldáshoz.

A tárolók egy teljes megoldásba való csoportosítása érdekében a csapat úgy döntött, hogy a Kubernetes-t használja. A Kubernetes a helyszínen és az összes nagyobb felhőplatformon fut. A Microsoft Azure teljes körű felügyelt kubernetes-környezettel rendelkezik, amelyet Azure Kubernetes Service-nek (AKS) hívunk. További információ az AKS-ről az Azure-beli Kubernetes bemutatása című képzési tervvel.

A segédprogram használatával a az CLI csapat hozzáadja az AKS-t a korábban létrehozott erőforráscsoporthoz. Egyetlen az paranccsal a fejlesztői csapat a következő lépéseket hajtja végre:

  • Két "csomópont" vagy számítási környezet hozzáadása a rugalmasság érdekében a tesztelési fázisban
  • SSH-kulcsok automatikus létrehozása a környezethez való hozzáféréshez
  • Csatolja az előző lépésekben létrehozott ACR szolgáltatást, hogy az AKS-fürt megtalálhassa az üzembe helyezéshez használni kívánt lemezképeket
az aks create --resource-group ReplaceWith_PoCResourceGroupName --name ReplaceWith_AzureKubernetesServiceName --node-count 2 --generate-ssh-keys --attach-acr ReplaceWith_AzureContainerRegistryName

A Kubernetes egy parancssori eszközt használ egy úgynevezett fürt kubectleléréséhez és vezérléséhez. A csapat a az CLI segédprogrammal tölti le és telepíti az kubectl eszközt:

az aks install-cli

Mivel jelenleg van kapcsolatuk az AKS-sel, megkérhetik, hogy küldje el az SSH-kulcsokat a segédprogram végrehajtásakor kubectl használandó kapcsolathoz:

az aks get-credentials --resource-group ReplaceWith_PoCResourceGroupName --name ReplaceWith_AzureKubernetesServiceName

Ezek a kulcsok egy .config nevű fájlban vannak tárolva a felhasználó könyvtárában. Ezzel a biztonsági környezettel a csapat kubectl get nodes a fürt csomópontjait jeleníti meg:

kubectl get nodes

Most a csapat az az CLI eszközzel listázhatja a képeket az ACR szolgáltatásban:

az acr list --resource-group ReplaceWith_PoCResourceGroupName --query "[].{acrLoginServer:loginServer}" --output table

Most már létrehozhatják a Kubernetes által az üzembe helyezés vezérléséhez használt jegyzékfájlt. Ez egy yaml formátumban tárolt szövegfájl. A fájlban a következő jegyzetekkel ellátott szöveg található flask2sql.yaml :

apiVersion: apps/v1
# The type of commands that will be sent, along with the name of the deployment
kind: Deployment
metadata:
  name: flask2sql
# This section sets the general specifications for the application
spec:
  replicas: 1
  selector:
    matchLabels:
      app: flask2sql
  strategy:
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
  minReadySeconds: 5 
  template:
    metadata:
      labels:
        app: flask2sql
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
# This section sets the location of the Image(s) in the deployment, and where to find them 
      containers:
      - name: flask2sql
        image:  bwoodyflask2sqlacr.azurecr.io/azure-flask2sql:v1
# Recall that the Flask application uses (by default) TCIP/IP port 5000 for access. This line tells Kubernetes that this "pod" uses that address.
        ports:
        - containerPort: 5000
---
apiVersion: v1
# This is the front-end of the application access, called a "Load Balancer"
kind: Service
metadata:
  name: flask2sql
spec:
  type: LoadBalancer
# this final step then sets the outside exposed port of the service to TCP/IP port 80, but maps it internally to the app's port of 5000
  ports:
  - protocol: TCP
    port: 80
    targetPort: 5000
  selector:
    app: flask2sql

A flask2sql.yaml fájl definiálása után a csapat üzembe helyezheti az alkalmazást a futó AKS-fürtön. Ez a kubectl apply paranccsal történik, amely mint emlékszik, továbbra is rendelkezik a fürt biztonsági környezetével. Ezután a rendszer elküldi a kubectl get service parancsot, hogy figyelje a fürt felépítését.

kubectl apply -f flask2sql.yaml
kubectl get service flask2sql --watch

Néhány pillanat múlva a "watch" parancs egy külső IP-címet ad vissza. Ekkor a csapat a CTRL-C billentyűkombinációt lenyomva megszakítja a figyelési parancsot, és rögzíti a terheléselosztó külső IP-címét.

Az alkalmazás tesztelése

Az utolsó lépésben beszerzett IP-cím (végpont) használatával a csapat ellenőrzi, hogy a helyi alkalmazás és a Docker-tároló kimenete megegyezik-e:

Screenshot from a web browser of the Flask return page when finally testing the container. The output is the same as before.

A fölöslegessé vált elemek eltávolítása

Az alkalmazás létrehozása, szerkesztése, dokumentálása és tesztelése után a csapat mostantól "lebonthatja" az alkalmazást. Ha mindent egyetlen erőforráscsoportban tart a Microsoft Azure-ban, egyszerűen törölheti a PoC-erőforráscsoportot a az CLI segédprogrammal:

az group delete -n ReplaceWith_PoCResourceGroupName -y

Megjegyzés:

Ha az Azure SQL Database-t egy másik erőforráscsoportban hozta létre, és már nincs rá szüksége, az Azure Portal használatával törölheti.

A PoC-projektet vezető csapattag a Microsoft Windowst használja munkaállomásként, és meg szeretné őrizni a Kubernetes titkos fájlját, de aktív helyként el szeretné távolítani a rendszerből. Egyszerűen átmásolhatják a fájlt egy config.old szövegfájlba, majd törölhetik:

copy c:\users\ReplaceWith_YourUserName\.kube\config c:\users\ReplaceWith_YourUserName\.kube\config.old
del c:\users\ReplaceWith_YourUserName\.kube\config

Kapcsolódó tartalom