Parte 4: Esempio di implementazione principale dell'applicazione

Parte precedente: Implementazione dell'API di terze parti

L'app principale in questo scenario è una semplice app Flask distribuita nel servizio app di Azure. L'app fornisce un endpoint API pubblico denominato /api/v1/getcode, che genera un codice per altri scopi nell'app (ad esempio, con l'autenticazione a due fattori per gli utenti umani). L'app principale fornisce anche una semplice home page che visualizza un collegamento all'endpoint API.

Lo script di provisioning dell'esempio esegue i passaggi seguenti:

1. Creare l'host del servizio app e distribuire il codice con il comando CLI di Azure, az webapp up.

2. Creare un account di archiviazione di Azure per l'app principale (usando az storage account create).

3. Crea una coda nell'account di archiviazione denominato "code-requests" (usando az storage queue create).

4. Per assicurarsi che l'app sia autorizzata a scrivere nella coda, usare az role assignment create per assegnare il ruolo "Collaboratore Dati Coda di Archiviazione" all'app. Per altre informazioni sui ruoli, vedere Come assegnare autorizzazioni di ruolo usando l'interfaccia della riga di comando di Azure.

Il codice principale dell'app è il seguente; spiegazioni di dettagli importanti sono fornite nelle prossime parti di questa serie.

from flask import Flask, request, jsonify
import requests, random, string, os
from datetime import datetime
from azure.keyvault.secrets import SecretClient
from azure.identity import DefaultAzureCredential
from azure.storage.queue import QueueClient

app = Flask(__name__)
app.config["DEBUG"] = True

number_url = os.environ["THIRD_PARTY_API_ENDPOINT"]

# Authenticate with Azure. First, obtain the DefaultAzureCredential
credential = DefaultAzureCredential()

# Next, get the client for the Key Vault. You must have first enabled managed identity
# on the App Service for the credential to authenticate with Key Vault.
key_vault_url = os.environ["KEY_VAULT_URL"]
keyvault_client = SecretClient(vault_url=key_vault_url, credential=credential)

# Obtain the secret: for this step to work you must add the app's service principal to
# the key vault's access policies for secret management.
api_secret_name = os.environ["THIRD_PARTY_API_SECRET_NAME"]
vault_secret = keyvault_client.get_secret(api_secret_name)

# The "secret" from Key Vault is an object with multiple properties. The key we
# want for the third-party API is in the value property. 
access_key = vault_secret.value

# Set up the Storage queue client to which we write messages
queue_url = os.environ["STORAGE_QUEUE_URL"]
queue_client = QueueClient.from_queue_url(queue_url=queue_url, credential=credential)


@app.route('/', methods=['GET'])
def home():
    return f'Home page of the main app. Make a request to <a href="./api/v1/getcode">/api/v1/getcode</a>.'


def random_char(num):
       return ''.join(random.choice(string.ascii_letters) for x in range(num))


@app.route('/api/v1/getcode', methods=['GET'])
def get_code():
    headers = {
        'Content-Type': 'application/json',
        'x-functions-key': access_key
        }

    r = requests.get(url = number_url, headers = headers)
    
    if (r.status_code != 200):       
        return "Could not get you a code.", r.status_code

    data = r.json()
    chars1 = random_char(3)
    chars2 = random_char(3)
    code_value = f"{chars1}-{data['value']}-{chars2}"
    code = { "code": code_value, "timestamp" : str(datetime.utcnow()) }

    # Log a queue message with the code for, say, a process that invalidates
    # the code after a certain period of time.
    queue_client.send_message(code)

    return jsonify(code)


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

Parte 5- Dipendenze e variabili di ambiente >>>