{"id":75150,"date":"2023-12-05T13:44:40","date_gmt":"2023-12-05T12:44:40","guid":{"rendered":"https:\/\/kinsta.com\/it\/?p=75150&#038;preview=true&#038;preview_id=75150"},"modified":"2023-12-28T16:24:22","modified_gmt":"2023-12-28T15:24:22","slug":"microservizi-python","status":"publish","type":"post","link":"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/","title":{"rendered":"Guida per costruire e distribuire microservizi con Python"},"content":{"rendered":"<p>Nello sviluppo software moderno, i microservizi sono emersi come un&#8217;architettura fondamentale, che consente scalabilit\u00e0, flessibilit\u00e0 e gestione efficiente di sistemi complessi.<\/p>\n<p>I microservizi sono applicazioni piccole e indipendenti che svolgono compiti specifici, consentendo una distribuzione e una scalabilit\u00e0 flessibili. Questo approccio modulare alla progettazione del software allenta l&#8217;accoppiamento (coupling) tra i componenti, migliorando la flessibilit\u00e0 e la gestibilit\u00e0 durante lo sviluppo.<\/p>\n<p>Questo articolo fornisce una panoramica sui <a href=\"https:\/\/kinsta.com\/it\/blog\/microservizi-vs-api\/\">microservizi<\/a>, sulle loro funzionalit\u00e0 e sulla loro creazione con <a href=\"https:\/\/kinsta.com\/it\/blog\/comandi-python\/\">Python<\/a>. Dimostra inoltre come distribuire i microservizi su Kinsta utilizzando un <a href=\"https:\/\/docs.sevalla.com\/applications\/build-options\/dockerfile\">Dockerfile<\/a>.<\/p>\n<div><\/div><kinsta-auto-toc heading=\"Table of Contents\" exclude=\"last\" list-style=\"arrow\" selector=\"h2\" count-number=\"-1\"><\/kinsta-auto-toc>\n<h2>Cosa sono i microservizi?<\/h2>\n<p>I microservizi sono servizi indipendenti e autonomi all&#8217;interno di un&#8217;applicazione, ognuno dei quali risponde a specifiche esigenze aziendali. Comunicano attraverso <a href=\"https:\/\/kinsta.com\/it\/blog\/api-endpoint\/\">API<\/a> leggere o message broker, formando un sistema completo.<\/p>\n<p>A differenza dei sistemi <a href=\"https:\/\/kinsta.com\/it\/blog\/function-as-a-service\/#how-does-faas-work\">monolitici<\/a> che scalano interamente in base alla domanda, i microservizi permettono di scalare singoli componenti ad alto traffico. Questa architettura facilita la gestione dei guasti e gli aggiornamenti delle funzionalit\u00e0, contrastando le limitazioni dei sistemi monolitici.<\/p>\n<p>I vantaggi dell&#8217;uso dei microservizi sono molteplici, come ad esempio:<\/p>\n<ul>\n<li><strong>Flessibilit\u00e0 e scalabilit\u00e0<\/strong>: il disaccoppiamento dei singoli servizi permette di aumentare il numero di nodi che eseguono un&#8217;istanza di un particolare servizio ad alto traffico.<\/li>\n<li><strong>Modularit\u00e0 del codice<\/strong>: ciascun servizio pu\u00f2 utilizzare uno stack tecnologico distinto, il che significa che si possono scegliere gli strumenti di sviluppo migliori per ciascuno di essi.<\/li>\n<\/ul>\n<p>Tuttavia, le architetture a microservizi presentano alcune sfide:<\/p>\n<ul>\n<li><strong>Monitoraggio di pi\u00f9 servizi<\/strong>: il monitoraggio dei singoli servizi di un sistema diventa difficile quando le istanze di un particolare servizio sono distribuite su pi\u00f9 nodi. Questa difficolt\u00e0 \u00e8 particolarmente evidente in caso di guasti alla rete o altri problemi di sistema.<\/li>\n<li><strong>Costi<\/strong>: lo sviluppo di applicazioni a microservizi pu\u00f2 essere molto pi\u00f9 costoso rispetto alla costruzione di sistemi monolitici a causa dei costi associati alla gestione di pi\u00f9 servizi. Ogni servizio richiede la propria infrastruttura e le proprie risorse, il che pu\u00f2 diventare costoso, soprattutto in caso di espansione del sistema.<\/li>\n<\/ul>\n<h2>Come progettare un microservizio con Python<\/h2>\n<p>Ora che conosciamo i vantaggi dell&#8217;utilizzo di un&#8217;architettura a microservizi, \u00e8 il momento di costruirne una con Python.<\/p>\n<p>Per questo esempio, supponiamo di voler costruire un&#8217;applicazione web di <a href=\"https:\/\/kinsta.com\/ecommerce\/\">e-commerce<\/a>. Il sito web ha diversi componenti, tra cui il catalogo dei prodotti, l&#8217;elenco degli ordini, il sistema di elaborazione dei pagamenti e i log, ognuno dei quali deve essere implementato come servizio indipendente. Inoltre, \u00e8 necessario stabilire un metodo di comunicazione da servizio a servizio per trasferire i dati tra questi servizi, come ad esempio <a href=\"https:\/\/kinsta.com\/it\/blog\/codici-di-stato-http\/\">HTTP<\/a>, in modo efficiente.<\/p>\n<p>Costruiamo un microservizio in Python per gestire un catalogo di prodotti. Il microservizio recuperer\u00e0 i dati dei prodotti da una fonte specificata e li restituir\u00e0 in formato JSON.<\/p>\n<h3>Prerequisiti<\/h3>\n<p>Per seguire questo tutorial, \u00e8 necessario avere:<\/p>\n<ul>\n<li>Familiarit\u00e0 con <a href=\"https:\/\/flask.palletsprojects.com\/en\/2.3.x\/\" target=\"_blank\" rel=\"noopener noreferrer\">Flask<\/a><\/li>\n<li><a href=\"https:\/\/kinsta.com\/it\/blog\/installare-python\/\">Python<\/a>, <a href=\"https:\/\/www.postman.com\/\" target=\"_blank\" rel=\"noopener noreferrer\">Postman Client<\/a> e <a href=\"https:\/\/www.docker.com\/products\/docker-desktop\/\" target=\"_blank\" rel=\"noopener noreferrer\">Docker Desktop<\/a> installati sulla macchina<\/li>\n<\/ul>\n<h3>1. Creare il progetto<\/h3>\n<ol start=\"1\">\n<li>Per iniziare, creiamo una cartella per il progetto chiamata <strong>flask-microservice<\/strong> e la directory corrente nella directory del progetto.<\/li>\n<li>Eseguiamo quindi <code>python3 --version<\/code> per verificare che Python sia installato correttamente sul computer.<\/li>\n<li>Installiamo <code>virtualenv<\/code> per creare un ambiente di sviluppo isolato per il microservizio Flask eseguendo questo comando:\n<pre><code class=\"language-bash\">pip3 install virtualenv<\/code><\/pre>\n<\/li>\n<li>Creiamo un ambiente virtuale eseguendo questo comando:\n<pre><code class=\"language-bash\">virtualenv venv<\/code><\/pre>\n<\/li>\n<li>Infine, attiviamo l&#8217;ambiente virtuale utilizzando uno dei seguenti comandi in base al sistema operativo del computer:\n<pre><code class=\"language-bash\"># Windows: \n.\\venv\\Scripts\\activate\n# Unix or macOS:\nsource venv\/bin\/activate<\/code><\/pre>\n<\/li>\n<\/ol>\n<h3>2. Configurare un server Flask<\/h3>\n<p>Nella directory principale, creiamo un file <strong>requirements.txt<\/strong> e aggiungiamo queste dipendenze.<\/p>\n<pre><code class=\"language-bash\">flask\nrequests<\/code><\/pre>\n<p>Eseguiamo il file <code><a href=\"https:\/\/kinsta.com\/it\/blog\/framework-python\/#the-python-package-manager-pip\">pip3<\/a><code> command on your terminal to install the dependencies.<\/code><\/code><\/p>\n<pre><code class=\"language-bash\">pip install -r requirements.txt<\/code><\/pre>\n<p>Successivamente, creiamo una nuova cartella nella directory principale e chiamiamola <strong>services<\/strong>. All&#8217;interno di questa cartella, creiamo un nuovo file, <strong>products.py<\/strong>, e aggiungiamo il codice sottostante per configurare un server Flask.<\/p>\n<pre><code class=\"language-python\">import requests\nimport os\nfrom flask import Flask, jsonify\napp = Flask(__name__)\nport = int(os.environ.get('PORT', 5000))\n\n@app.route(\"\/\")\ndef home():\n    return \"Hello, this is a Flask Microservice\"\nif __name__ == \"__main__\":\n    app.run(debug=True, host=\"0.0.0.0\", port=port)<\/code><\/pre>\n<p>Nel codice qui sopra, viene configurato un server Flask di base. Inizializza un&#8217;applicazione Flask, definisce una singola route per l&#8217;URL principale (<code>\"\/\"<\/code>) e, quando vi si accede, visualizza il messaggio <code>\"Hello, this is a Flask Microservice\"<\/code>. Il server viene eseguito su una porta specificata, ottenuta da una variabile d&#8217;ambiente o predefinita alla porta <code>5000<\/code>, e si avvia in modalit\u00e0 di debug per essere pronto a gestire le richieste in arrivo.<\/p>\n<h3>3. Definire gli endpoint dell&#8217;API<\/h3>\n<p>Una volta configurato il server, creiamo un endpoint API per un microservizio che recupera i dati dei prodotti da un&#8217;<a href=\"https:\/\/dummyjson.com\" target=\"_blank\" rel=\"noopener noreferrer\">API disponibile pubblicamente<\/a>. Aggiungiamo questo codice al file <strong>products.py<\/strong>:<\/p>\n<pre><code class=\"language-python\">BASE_URL = \"https:\/\/dummyjson.com\"\n@app.route('\/products', methods=['GET'])\ndef get_products():\n    response = requests.get(f\"{BASE_URL}\/products\")\n    if response.status_code != 200:\n        return jsonify({'error': response.json()['message']}), response.status_code\n    products = []\n    for product in response.json()['products']:\n        product_data = {\n            'id': product['id'],\n            'title': product['title'],\n            'brand': product['brand'],\n            'price': product['price'],\n            'description': product['description']\n        }\n        products.append(product_data)\n    return jsonify({'data': products}), 200 if products else 204<\/code><\/pre>\n<p>Il codice precedente crea un endpoint <code>\/products<\/code> nel server Flask. Quando vi si accede tramite una richiesta GET, recupera i dati dei prodotti da un&#8217;API fittizia. In caso di successo, elabora i dati recuperati, estrae i dettagli del prodotto e restituisce le informazioni in formato JSON. In caso di errori o di assenza di dati disponibili, risponde con un messaggio di errore e un codice di stato appropriati.<\/p>\n<h3>4. Testare il microservizio<\/h3>\n<p>A questo punto, abbiamo configurato con successo un semplice microservizio. Per avviare il servizio, avviamo il server di sviluppo, che inizier\u00e0 a funzionare all&#8217;indirizzo <code>http:\/\/localhost:5000<\/code>.<\/p>\n<pre><code class=\"language-bash\">flask --app services\/products run<\/code><\/pre>\n<p>Poi possiamo fare una richiesta <code>GET<\/code> all&#8217;endpoint <code>\/products<\/code> usando il client Postman; dovremmo vedere una risposta simile a quella dello screenshot qui sotto.<\/p>\n<figure id=\"attachment_105526\" aria-describedby=\"caption-attachment-105526\" style=\"width: 1001px\" class=\"wp-caption alignnone\"><img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/kinsta.com\/wp-content\/uploads\/2023\/11\/testing-endpoint-locally.jpg\" alt=\"Richiesta GET riuscita all'endpoint del prodotto API fittizio in Postman\" width=\"1001\" height=\"471\"><figcaption id=\"caption-attachment-105526\" class=\"wp-caption-text\">Test della richiesta HTTP API <code>GET<\/code> in Postman.<\/figcaption><\/figure>\n<h2>Come implementare l&#8217;autenticazione e l&#8217;autorizzazione in un microservizio in Python<\/h2>\n<p>Quando si costruiscono microservizi, \u00e8 importante implementare misure di sicurezza solide come l&#8217;autenticazione e l&#8217;autorizzazione. La sicurezza del microservizio assicura che solo gli utenti autorizzati possano accedere e utilizzare il servizio, proteggendo i dati sensibili e prevenendo gli attacchi malevoli.<\/p>\n<p>Un metodo efficace per implementare l&#8217;autenticazione e l&#8217;autorizzazione sicura nei microservizi \u00e8 rappresentato dai JSON Web Tokens (JWT).<\/p>\n<p>I JWT sono uno standard aperto molto diffuso che offre un modo sicuro ed efficiente di trasmettere informazioni di autenticazione tra client e server. Si tratta di token compatti, crittografati e firmati digitalmente che vengono trasmessi insieme alle richieste HTTP. Includendo un JWT in ogni richiesta, il server pu\u00f2 verificare rapidamente l&#8217;identit\u00e0 e i permessi di un utente.<\/p>\n<p>Per implementare l&#8217;autenticazione JWT nel microservizio, procediamo come segue:<\/p>\n<ol start=\"1\">\n<li>Aggiungiamo il pacchetto <code>pyjwt<\/code> di Python al file <strong>requirements.txt<\/strong> e reinstalliamo le dipendenze usando <code>pip install -r requirements.txt<\/code>.<\/li>\n<li>Poich\u00e9 il servizio non ha un database dedicato, creiamo un file <strong>users.json<\/strong> nella directory principale del progetto per memorizzare un elenco di utenti autorizzati. Incolliamo il codice sottostante nel file:\n<pre><code class=\"language-json\">[\n    {   \n        \"id\": 1,\n        \"username\": \"admin\",\n        \"password\": \"admin\"\n    \n    }\n]<\/code><\/pre>\n<p><aside role=\"note\" class=\"wp-block-kinsta-notice is-style-info\">\n            <h3>Info<\/h3>\n        <p>Potete configurare facilmente il database che preferite (<a href=\"https:\/\/kinsta.com\/it\/blog\/cosa-e-postgresql\/\">PostgreSQL<\/a>, <a href=\"https:\/\/kinsta.com\/it\/blog\/mariadb-python\/\">MariaDB<\/a>, <a href=\"https:\/\/kinsta.com\/it\/blog\/redis-docker\/\">Redis<\/a> e <a href=\"https:\/\/kinsta.com\/it\/argomenti\/database-mysql\/\">MySQL<\/a>) per i vostri microservizi con il nostro servizio di <a href=\"https:\/\/sevalla.com\/database-hosting\/\">Hosting di Database<\/a>.<\/p>\n<\/aside>\n<\/li>\n<li>Quindi, nel file <strong>services\/products.py<\/strong>, sostituiamo le dichiarazioni di importazione con le seguenti:\n<pre><code class=\"language-python\">import requests \nfrom flask import Flask, jsonify, request, make_response\nimport jwt\nfrom functools import wraps\nimport json\nimport os\nfrom jwt.exceptions import DecodeError<\/code><\/pre>\n<p>Stiamo importando questi moduli per gestire le richieste HTTP, creare un&#8217;app Flask, gestire i dati JSON, implementare l&#8217;autenticazione basata su JWT e gestire le eccezioni, abilitando un&#8217;ampia gamma di funzionalit\u00e0 all&#8217;interno del server <a href=\"https:\/\/kinsta.com\/it\/blog\/flask-vs-django\/\">Flask<\/a>.<\/li>\n<li>Aggiungiamo il seguente codice sotto la creazione dell&#8217;istanza dell&#8217;app Flask per generare una chiave segreta che verr\u00e0 utilizzata per firmare i token JWT.\n<pre><code class=\"language-python\">app.config['SECRET_KEY'] = os.urandom(24)<\/code><\/pre>\n<\/li>\n<li>Per verificare i JWT, creiamo una funzione decoratore e aggiungiamo il seguente codice sopra le route API nel codice del server Flask. Questa funzione decoratore autenticher\u00e0 e convalider\u00e0 gli utenti prima che accedano alle route protetti.\n<pre><code class=\"language-python\">def token_required(f):\n    @wraps(f)\n    def decorated(*args, **kwargs):\n        token = request.cookies.get('token')\n        if not token:\n            return jsonify({'error': 'Authorization token is missing'}), 401\n        try:\n            data = jwt.decode(token, app.config['SECRET_KEY'], algorithms=[\"HS256\"])\n            current_user_id = data['user_id']\n        except DecodeError:\n            return jsonify({'error': 'Authorization token is invalid'}), 401\n        return f(current_user_id, *args, **kwargs)\n    return decorated<\/code><\/pre>\n<p>Questa funzione decoratore controlla le richieste HTTP in arrivo alla ricerca di un token di autorizzazione JWT, che dovrebbe essere presente nelle intestazioni della richiesta o nei cookie. Se il token manca o non \u00e8 valido, il decoratore invia un messaggio <code>unauthorized status code<\/code> come risposta.<\/p>\n<p>Al contrario, se \u00e8 presente un token valido, il decoratore estrae l&#8217;ID utente dopo averlo decodificato. Questo processo salvaguarda gli endpoint API protetti consentendo l&#8217;accesso solo agli utenti autorizzati.<\/li>\n<li>Definiamo un endpoint API per l&#8217;autenticazione dell&#8217;utente utilizzando il codice seguente.\n<pre><code class=\"language-python\">with open('users.json', 'r') as f:\n    users = json.load(f)\n@app.route('\/auth', methods=['POST'])\ndef authenticate_user():\n    if request.headers['Content-Type'] != 'application\/json':\n        return jsonify({'error': 'Unsupported Media Type'}), 415\n    username = request.json.get('username')\n    password = request.json.get('password')\n    for user in users:\n        if user['username'] == username and user['password'] == password:\n            token = jwt.encode({'user_id': user['id']}, app.config['SECRET_KEY'],algorithm=\"HS256\")\n            response = make_response(jsonify({'message': 'Authentication successful'}))\n            response.set_cookie('token', token)\n            return response, 200\n    return jsonify({'error': 'Invalid username or password'}), 401<\/code><\/pre>\n<p>Per autenticare e autorizzare gli utenti, l&#8217;endpoint API <code>\/auth<\/code> controlla le credenziali contenute nel payload JSON della richiesta <code>POST<\/code> rispetto all&#8217;elenco degli utenti autorizzati. Se le credenziali sono valide, genera un token JWT utilizzando l&#8217;ID dell&#8217;utente e la chiave segreta dell&#8217;applicazione e imposta il token come cookie nella risposta. Gli utenti possono ora utilizzare questo token per effettuare le successive richieste API.<\/p>\n<p>Dopo aver creato l&#8217;endpoint <code>\/auth<\/code>, usiamo Postman per inviare una richiesta HTTP <code>POST<\/code> a <code>http:\/\/localhost:5000\/auth<\/code>. Nel corpo della richiesta, includiamo le credenziali del finto utente amministratore che abbiamo creato.<\/p>\n<figure id=\"attachment_105526\" aria-describedby=\"caption-attachment-105526\" style=\"width: 1001px\" class=\"wp-caption alignnone\"><img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/kinsta.com\/wp-content\/uploads\/2023\/11\/authentication-request.png\" alt=\"La richiesta di Postman mostra il corpo della richiesta\" width=\"1001\" height=\"471\"><figcaption id=\"caption-attachment-105526\" class=\"wp-caption-text\">La richiesta di Postman mostra il corpo della richiesta.<\/figcaption><\/figure>\n<p>Se la richiesta va a buon fine, l&#8217;API generer\u00e0 un token JWT, lo imposter\u00e0 nei cookie di Postman e invier\u00e0 una risposta di successo autenticata.<\/li>\n<li>Infine, aggiorniamo l&#8217;endpoint dell&#8217;API <code>GET<\/code> per controllare e verificare il token JWT utilizzando il codice seguente:\n<pre><code class=\"language-python\">@app.route('\/products', methods=['GET'])\n@token_required\ndef get_products(current_user_id):\n    headers = {'Authorization': f'Bearer {request.cookies.get(\"token\")}'}    \n    response = requests.get(f\"{BASE_URL}\/products\", headers=headers)\n    if response.status_code != 200:\n        return jsonify({'error': response.json()['message']}), response.status_code\n    products = []\n    for product in response.json()['products']:\n        product_data = {\n            'id': product['id'],\n            'title': product['title'],\n            'brand': product['brand'],\n            'price': product['price'],\n            'description': product['description']\n        }\n        products.append(product_data)\n    return jsonify({'data': products}), 200 if products else 204<\/code><\/pre>\n<\/li>\n<\/ol>\n<h2>Come containerizzare i microservizi Python con Docker<\/h2>\n<p><a href=\"https:\/\/kinsta.com\/it\/blog\/cosa-e-docker\/\">Docker<\/a> \u00e8 una piattaforma che impacchetta le applicazioni e le loro dipendenze in un ambiente di sviluppo isolato. L&#8217;impacchettamento dei microservizi in container ottimizza i processi di distribuzione e gestione nei server, poich\u00e9 ogni servizio viene eseguito in modo indipendente nel proprio container.<\/p>\n<p>Per containerizzare il microservizio, dobbiamo creare un&#8217;immagine Docker da un <a href=\"https:\/\/docs.sevalla.com\/applications\/build-options\/dockerfile\">Dockerfile<\/a> che specifichi le dipendenze necessarie per eseguire l&#8217;applicazione in un container. Creiamo un <strong>Dockerfile<\/strong> nella directory principale del progetto e aggiungiamo queste istruzioni:<\/p>\n<pre><code class=\"language-bash\">FROM python:3.9-alpine\nWORKDIR \/app\nCOPY requirements.txt .\/\nRUN pip install -r requirements.txt\nCOPY . .\nEXPOSE 5000\nCMD [\"python\", \".\/services\/products.py\"]<\/code><\/pre>\n<p>Prima di creare l&#8217;immagine, diamo un&#8217;occhiata ai seguenti comandi:<\/p>\n<ul>\n<li><code>FROM<\/code>: indica a Docker quale immagine di base utilizzare. Un&#8217;immagine di base \u00e8 un&#8217;istanza precostituita contenente il software e le dipendenze per eseguire l&#8217;applicazione Flask in un container.<\/li>\n<li><code>WORKDIR<\/code>: imposta la directory specificata all&#8217;interno del container come directory di lavoro.<\/li>\n<li><code>COPY requirements.txt .\/<\/code>: copia le dipendenze nel file <strong>requirements.txt<\/strong> nel file <strong>requirements.txt<\/strong> del container.<\/li>\n<li><code>RUN<\/code> &#8211; Esegue il comando specificato per installare le dipendenze richieste dall&#8217;immagine.<\/li>\n<li><code>COPY . .<\/code>: copia tutti i file dalla directory principale del progetto alla directory di lavoro all&#8217;interno del container.<\/li>\n<li><code>EXPOSE<\/code>: specifica la porta su cui il container ascolter\u00e0 le richieste. Tuttavia, Docker non pubblica la porta sul computer host.<\/li>\n<li><code>CMD<\/code>: specifica il comando predefinito da eseguire all&#8217;avvio del container.<\/li>\n<\/ul>\n<p>Successivamente, aggiungiamo un file <strong>.dockerignore<\/strong> nella directory principale del progetto per specificare i file che l&#8217;immagine Docker deve escludere. Limitare il contenuto dell&#8217;immagine ridurr\u00e0 le dimensioni finali e il tempo di build associato.<\/p>\n<pre><code class=\"language-bash\">\/venv\n\/services\/__pycache__\/\n.gitignore<\/code><\/pre>\n<p>Ora, eseguiamo il comando seguente per creare l&#8217;immagine Docker:<\/p>\n<pre><code class=\"language-bash\">docker build -t flask-microservice .<\/code><\/pre>\n<p>Infine, una volta creata l&#8217;immagine, possiamo eseguire il microservizio in un container Docker utilizzando il seguente comando:<\/p>\n<pre><code class=\"language-bash\">docker run -p 5000:5000 flask-microservice<\/code><\/pre>\n<p>Questo comando avvier\u00e0 un container Docker che esegue il microservizio ed esporr\u00e0 la porta 5000 del container alla porta 5000 del computer host, consentendo di effettuare richieste HTTP dal browser web o da Postman utilizzando l&#8217;URL <code>http:\/\/localhost:5000<\/code>.<\/p>\n<h2>Distribuire microservizi Python con Kinsta<\/h2>\n<p>Kinsta offre soluzioni di hosting gestito per applicazioni web e database: si possono distribuire e gestire senza problemi i propri microservizi Python e le API di backend in un ambiente di produzione.<\/p>\n<p>Seguiamo questi passaggi per preparare il microservizio Flask alla distribuzione con MyKinsta:<\/p>\n<ol start=\"1\">\n<li>Per prima cosa, creiamo un nuovo <strong>Procfile<\/strong> nella directory principale e aggiungiamo il codice qui sotto. Questo specifica il comando per eseguire il microservizio Flask sul server HTTP Gunicorn WSGI di Kinsta per le applicazioni Python.\n<pre><code class=\"language-bash\">web: gunicorn services.wsgi<\/code><\/pre>\n<\/li>\n<li>Nel file <strong>requirements.txt<\/strong>, aggiungiamo la dipendenza Gunicorn:\n<pre><code class=\"language-bash\">gunicorn==20.1.*<\/code><\/pre>\n<\/li>\n<li>Quindi, creiamo un nuovo file <strong>services\/wsgi.py<\/strong> e aggiungiamo il codice seguente.\n<pre><code class=\"language-python\">from services.products import app as application\nif __name__ == \"__main__\":\n                application.run()<\/code><\/pre>\n<\/li>\n<li>Creiamo un file <strong>.gitignore<\/strong> nella cartella principale del progetto e aggiungiamo quanto segue:\n<pre><code class=\"language-bash\">services\/__pycache__\nvenv<\/code><\/pre>\n<\/li>\n<li>Infine, creiamo un nuovo repository su GitHub e inviamo i file del progetto.<\/li>\n<\/ol>\n<p>Quando il repository sar\u00e0 pronto, basta seguire questi passaggi per distribuire il microservizio Flask su Kinsta:<\/p>\n<ol start=\"1\">\n<li style=\"list-style-type: none\">\n<ol start=\"1\">\n<li>Accedere o creare un account per visualizzare la dashboard <a href=\"https:\/\/my.kinsta.com\/?lang=it\" target=\"_blank\" rel=\"noopener noreferrer\">MyKinsta<\/a>.<\/li>\n<li>Autorizzare Kinsta con il provider Git (<a href=\"https:\/\/docs.sevalla.com\/applications\/git\/bitbucket#grant-access-to-the-kinsta-bitbucket-application\">Bitbucket<\/a>, <a href=\"https:\/\/docs.sevalla.com\/applications\/git\/github#authenticate-and-authorize\">GitHub<\/a> o <a href=\"https:\/\/docs.sevalla.com\/applications\/git\/gitlab#authorize-the-kinsta-gitlab-application\">GitLab<\/a>).<\/li>\n<li>Cliccare su <strong>Applicazioni<\/strong> nella barra laterale di sinistra e poi su <strong>Aggiungi applicazione<\/strong>.<\/li>\n<li>Nel cruscotto, cliccare su <strong>Aggiungi servizio<\/strong> e selezionare <strong>Applicazione<\/strong>.<\/li>\n<li>Selezionare il repository e il branch da cui si desidera effettuare il deploy.<\/li>\n<li>Assegnare un nome unico all&#8217;applicazione e scegliere la <strong>posizione<\/strong> del <strong>data center<\/strong>.<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n<ol start=\"1\">\n<li style=\"list-style-type: none\">\n<ol start=\"1\">\n<li>Per configurare l&#8217;ambiente di <strong>build<\/strong>, selezionare l&#8217;opzione per utilizzare un <a href=\"https:\/\/docs.sevalla.com\/applications\/build-options\/dockerfile\"><strong>Dockerfile<\/strong> per creare l&#8217;immagine del container<\/a>.<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n<ol start=\"1\">\n<li>Fornire il percorso del file Docker e il contesto.<\/li>\n<li>Infine, controllare le altre informazioni e cliccare su <strong>Crea applicazione<\/strong>.<\/li>\n<\/ol>\n<h3>Testare il microservizio<\/h3>\n<p>Una volta che il processo di distribuzione sar\u00e0 andato a buon fine, clicchiamo sull&#8217;<a href=\"https:\/\/flask-microservice-tutorial-3dhgr.kinsta.app\/\" target=\"_blank\" rel=\"noopener noreferrer\">URL<\/a> fornito per testare il microservizio effettuando delle richieste HTTP in Postman. Effettuiamo una richiesta <code>GET<\/code> all&#8217;endpoint principale.<\/p>\n<figure id=\"attachment_105526\" aria-describedby=\"caption-attachment-105526\" style=\"width: 1001px\" class=\"wp-caption alignnone\"><img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/kinsta.com\/wp-content\/uploads\/2023\/11\/testing-deployed-microservice.jpg\" alt=\"Richiesta GET riuscita all'URL del microservizio distribuito per la route Home\" width=\"1001\" height=\"471\"><figcaption id=\"caption-attachment-105526\" class=\"wp-caption-text\">Eseguire una richiesta HTTP API <code>GET<\/code> all&#8217;endpoint <code>product<\/code> del microservizio.<\/figcaption><\/figure>\n<p>Per autenticarci e generare un token JWT, inviamo una richiesta <code>POST<\/code> all&#8217;endpoint API <code>\/auth<\/code>, passando le credenziali dell&#8217;amministratore nel corpo della richiesta.<\/p>\n<figure id=\"attachment_105526\" aria-describedby=\"caption-attachment-105526\" style=\"width: 1001px\" class=\"wp-caption alignnone\"><img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/kinsta.com\/wp-content\/uploads\/2023\/11\/microservice-authentication.jpg\" alt=\"Una richiesta POST a un endpoint Auth di un microservizio per l'autenticazione in Postman\" width=\"1001\" height=\"471\"><figcaption id=\"caption-attachment-105526\" class=\"wp-caption-text\">Richiesta HTTP API <code>POST<\/code> all&#8217;endpoint <code>auth<\/code> del microservizio.<\/figcaption><\/figure>\n<p>Infine, dopo esserci autenticati, eseguiramo una richiesta <code>GET<\/code> all&#8217;endpoint <code>\/products<\/code> per recuperare i dati.<\/p>\n<figure id=\"attachment_105526\" aria-describedby=\"caption-attachment-105526\" style=\"width: 1001px\" class=\"wp-caption alignnone\"><img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/kinsta.com\/wp-content\/uploads\/2023\/11\/products-list.jpg\" alt=\"Richiesta HTTP API GET riuscita all'endpoint dei prodotti in Postman\" width=\"1001\" height=\"471\"><figcaption id=\"caption-attachment-105526\" class=\"wp-caption-text\">Richiesta HTTP API <code>GET<\/code> all&#8217;endpoint del microservizio <code>products<\/code>.<\/figcaption><\/figure>\n<h2>Riepilogo<\/h2>\n<p>Man mano che le applicazioni crescono in dimensioni e complessit\u00e0, \u00e8 fondamentale adottare modelli di architettura che permettano ai sistemi software di scalare senza affaticare le risorse disponibili.<\/p>\n<p>L&#8217;architettura a microservizi offre scalabilit\u00e0, flessibilit\u00e0 di sviluppo e manutenibilit\u00e0, rendendo pi\u00f9 facile la gestione di applicazioni complesse.<\/p>\n<p>Kinsta semplifica il processo di hosting dei vostri microservizi. Vi permette di utilizzare senza problemi il vostro database preferito e di ospitare comodamente sia l&#8217;<a href=\"https:\/\/sevalla.com\/application-hosting\/\">applicazione<\/a> che il <a href=\"https:\/\/sevalla.com\/database-hosting\/\">database<\/a> attraverso una dashboard unificata.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Nello sviluppo software moderno, i microservizi sono emersi come un&#8217;architettura fondamentale, che consente scalabilit\u00e0, flessibilit\u00e0 e gestione efficiente di sistemi complessi. I microservizi sono applicazioni piccole &#8230;<\/p>\n","protected":false},"author":199,"featured_media":75151,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_kinsta_gated_content":false,"_kinsta_gated_content_redirect":"","footnotes":""},"tags":[],"topic":[26216,26213,26215],"class_list":["post-75150","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","topic-docker","topic-postgresql","topic-python"],"yoast_head":"<!-- This site is optimized with the Yoast SEO Premium plugin v24.6 (Yoast SEO v24.6) - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>Guida per costruire e distribuire microservizi con Python - Kinsta\u00ae<\/title>\n<meta name=\"description\" content=\"Scopri come costruire e distribuire microservizi efficienti utilizzando Python per semplificare lo sviluppo e migliorare le prestazioni!\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/\" \/>\n<meta property=\"og:locale\" content=\"it_IT\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Guida per costruire e distribuire microservizi con Python\" \/>\n<meta property=\"og:description\" content=\"Scopri come costruire e distribuire microservizi efficienti utilizzando Python per semplificare lo sviluppo e migliorare le prestazioni!\" \/>\n<meta property=\"og:url\" content=\"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/\" \/>\n<meta property=\"og:site_name\" content=\"Kinsta\u00ae\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/kinstaitalia\/\" \/>\n<meta property=\"article:published_time\" content=\"2023-12-05T12:44:40+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-12-28T15:24:22+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/kinsta.com\/it\/wp-content\/uploads\/sites\/2\/2023\/12\/python-microservices.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"3043\" \/>\n\t<meta property=\"og:image:height\" content=\"1522\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Jeremy Holcombe\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:description\" content=\"Scopri come costruire e distribuire microservizi efficienti utilizzando Python per semplificare lo sviluppo e migliorare le prestazioni!\" \/>\n<meta name=\"twitter:image\" content=\"https:\/\/kinsta.com\/it\/wp-content\/uploads\/sites\/2\/2023\/12\/python-microservices.jpg\" \/>\n<meta name=\"twitter:creator\" content=\"@Kinsta_IT\" \/>\n<meta name=\"twitter:site\" content=\"@Kinsta_IT\" \/>\n<meta name=\"twitter:label1\" content=\"Scritto da\" \/>\n\t<meta name=\"twitter:data1\" content=\"Jeremy Holcombe\" \/>\n\t<meta name=\"twitter:label2\" content=\"Tempo di lettura stimato\" \/>\n\t<meta name=\"twitter:data2\" content=\"12 minuti\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/\"},\"author\":{\"name\":\"Jeremy Holcombe\",\"@id\":\"https:\/\/kinsta.com\/it\/#\/schema\/person\/4eee42881d7b5a73ebb4f58dd5223b21\"},\"headline\":\"Guida per costruire e distribuire microservizi con Python\",\"datePublished\":\"2023-12-05T12:44:40+00:00\",\"dateModified\":\"2023-12-28T15:24:22+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/\"},\"wordCount\":2154,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\/\/kinsta.com\/it\/#organization\"},\"image\":{\"@id\":\"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/kinsta.com\/it\/wp-content\/uploads\/sites\/2\/2023\/12\/python-microservices-3.jpg\",\"inLanguage\":\"it-IT\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/\",\"url\":\"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/\",\"name\":\"Guida per costruire e distribuire microservizi con Python - Kinsta\u00ae\",\"isPartOf\":{\"@id\":\"https:\/\/kinsta.com\/it\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/kinsta.com\/it\/wp-content\/uploads\/sites\/2\/2023\/12\/python-microservices-3.jpg\",\"datePublished\":\"2023-12-05T12:44:40+00:00\",\"dateModified\":\"2023-12-28T15:24:22+00:00\",\"description\":\"Scopri come costruire e distribuire microservizi efficienti utilizzando Python per semplificare lo sviluppo e migliorare le prestazioni!\",\"breadcrumb\":{\"@id\":\"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/#breadcrumb\"},\"inLanguage\":\"it-IT\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"it-IT\",\"@id\":\"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/#primaryimage\",\"url\":\"https:\/\/kinsta.com\/it\/wp-content\/uploads\/sites\/2\/2023\/12\/python-microservices-3.jpg\",\"contentUrl\":\"https:\/\/kinsta.com\/it\/wp-content\/uploads\/sites\/2\/2023\/12\/python-microservices-3.jpg\",\"width\":3043,\"height\":1522},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/kinsta.com\/it\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Python\",\"item\":\"https:\/\/kinsta.com\/it\/argomenti\/python\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Guida per costruire e distribuire microservizi con Python\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/kinsta.com\/it\/#website\",\"url\":\"https:\/\/kinsta.com\/it\/\",\"name\":\"Kinsta\u00ae\",\"description\":\"Soluzioni di hosting premium, veloci e sicure\",\"publisher\":{\"@id\":\"https:\/\/kinsta.com\/it\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/kinsta.com\/it\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"it-IT\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/kinsta.com\/it\/#organization\",\"name\":\"Kinsta\",\"url\":\"https:\/\/kinsta.com\/it\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"it-IT\",\"@id\":\"https:\/\/kinsta.com\/it\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/kinsta.com\/it\/wp-content\/uploads\/sites\/2\/2023\/12\/kinsta-logo.jpeg\",\"contentUrl\":\"https:\/\/kinsta.com\/it\/wp-content\/uploads\/sites\/2\/2023\/12\/kinsta-logo.jpeg\",\"width\":500,\"height\":500,\"caption\":\"Kinsta\"},\"image\":{\"@id\":\"https:\/\/kinsta.com\/it\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"https:\/\/www.facebook.com\/kinstaitalia\/\",\"https:\/\/x.com\/Kinsta_IT\",\"https:\/\/www.instagram.com\/kinstahosting\/\",\"https:\/\/www.linkedin.com\/company\/kinsta\/\",\"https:\/\/www.pinterest.com\/kinstahosting\/\",\"https:\/\/www.youtube.com\/c\/Kinsta\"]},{\"@type\":\"Person\",\"@id\":\"https:\/\/kinsta.com\/it\/#\/schema\/person\/4eee42881d7b5a73ebb4f58dd5223b21\",\"name\":\"Jeremy Holcombe\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"it-IT\",\"@id\":\"https:\/\/kinsta.com\/it\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/0e17001f3bb37dbbe54fceef9bb547fa?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/0e17001f3bb37dbbe54fceef9bb547fa?s=96&d=mm&r=g\",\"caption\":\"Jeremy Holcombe\"},\"description\":\"Senior Editor at Kinsta, WordPress Web Developer, and Content Writer. Outside of all things WordPress, I enjoy the beach, golf, and movies. I also have tall people problems.\",\"sameAs\":[\"https:\/\/www.linkedin.com\/in\/jeremyholcombe\/\"],\"url\":\"https:\/\/kinsta.com\/it\/blog\/author\/jeremyholcombe\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Guida per costruire e distribuire microservizi con Python - Kinsta\u00ae","description":"Scopri come costruire e distribuire microservizi efficienti utilizzando Python per semplificare lo sviluppo e migliorare le prestazioni!","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/","og_locale":"it_IT","og_type":"article","og_title":"Guida per costruire e distribuire microservizi con Python","og_description":"Scopri come costruire e distribuire microservizi efficienti utilizzando Python per semplificare lo sviluppo e migliorare le prestazioni!","og_url":"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/","og_site_name":"Kinsta\u00ae","article_publisher":"https:\/\/www.facebook.com\/kinstaitalia\/","article_published_time":"2023-12-05T12:44:40+00:00","article_modified_time":"2023-12-28T15:24:22+00:00","og_image":[{"width":3043,"height":1522,"url":"https:\/\/kinsta.com\/it\/wp-content\/uploads\/sites\/2\/2023\/12\/python-microservices.jpg","type":"image\/jpeg"}],"author":"Jeremy Holcombe","twitter_card":"summary_large_image","twitter_description":"Scopri come costruire e distribuire microservizi efficienti utilizzando Python per semplificare lo sviluppo e migliorare le prestazioni!","twitter_image":"https:\/\/kinsta.com\/it\/wp-content\/uploads\/sites\/2\/2023\/12\/python-microservices.jpg","twitter_creator":"@Kinsta_IT","twitter_site":"@Kinsta_IT","twitter_misc":{"Scritto da":"Jeremy Holcombe","Tempo di lettura stimato":"12 minuti"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/#article","isPartOf":{"@id":"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/"},"author":{"name":"Jeremy Holcombe","@id":"https:\/\/kinsta.com\/it\/#\/schema\/person\/4eee42881d7b5a73ebb4f58dd5223b21"},"headline":"Guida per costruire e distribuire microservizi con Python","datePublished":"2023-12-05T12:44:40+00:00","dateModified":"2023-12-28T15:24:22+00:00","mainEntityOfPage":{"@id":"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/"},"wordCount":2154,"commentCount":0,"publisher":{"@id":"https:\/\/kinsta.com\/it\/#organization"},"image":{"@id":"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/#primaryimage"},"thumbnailUrl":"https:\/\/kinsta.com\/it\/wp-content\/uploads\/sites\/2\/2023\/12\/python-microservices-3.jpg","inLanguage":"it-IT","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/kinsta.com\/it\/blog\/microservizi-python\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/","url":"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/","name":"Guida per costruire e distribuire microservizi con Python - Kinsta\u00ae","isPartOf":{"@id":"https:\/\/kinsta.com\/it\/#website"},"primaryImageOfPage":{"@id":"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/#primaryimage"},"image":{"@id":"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/#primaryimage"},"thumbnailUrl":"https:\/\/kinsta.com\/it\/wp-content\/uploads\/sites\/2\/2023\/12\/python-microservices-3.jpg","datePublished":"2023-12-05T12:44:40+00:00","dateModified":"2023-12-28T15:24:22+00:00","description":"Scopri come costruire e distribuire microservizi efficienti utilizzando Python per semplificare lo sviluppo e migliorare le prestazioni!","breadcrumb":{"@id":"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/#breadcrumb"},"inLanguage":"it-IT","potentialAction":[{"@type":"ReadAction","target":["https:\/\/kinsta.com\/it\/blog\/microservizi-python\/"]}]},{"@type":"ImageObject","inLanguage":"it-IT","@id":"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/#primaryimage","url":"https:\/\/kinsta.com\/it\/wp-content\/uploads\/sites\/2\/2023\/12\/python-microservices-3.jpg","contentUrl":"https:\/\/kinsta.com\/it\/wp-content\/uploads\/sites\/2\/2023\/12\/python-microservices-3.jpg","width":3043,"height":1522},{"@type":"BreadcrumbList","@id":"https:\/\/kinsta.com\/it\/blog\/microservizi-python\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/kinsta.com\/it\/"},{"@type":"ListItem","position":2,"name":"Python","item":"https:\/\/kinsta.com\/it\/argomenti\/python\/"},{"@type":"ListItem","position":3,"name":"Guida per costruire e distribuire microservizi con Python"}]},{"@type":"WebSite","@id":"https:\/\/kinsta.com\/it\/#website","url":"https:\/\/kinsta.com\/it\/","name":"Kinsta\u00ae","description":"Soluzioni di hosting premium, veloci e sicure","publisher":{"@id":"https:\/\/kinsta.com\/it\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/kinsta.com\/it\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"it-IT"},{"@type":"Organization","@id":"https:\/\/kinsta.com\/it\/#organization","name":"Kinsta","url":"https:\/\/kinsta.com\/it\/","logo":{"@type":"ImageObject","inLanguage":"it-IT","@id":"https:\/\/kinsta.com\/it\/#\/schema\/logo\/image\/","url":"https:\/\/kinsta.com\/it\/wp-content\/uploads\/sites\/2\/2023\/12\/kinsta-logo.jpeg","contentUrl":"https:\/\/kinsta.com\/it\/wp-content\/uploads\/sites\/2\/2023\/12\/kinsta-logo.jpeg","width":500,"height":500,"caption":"Kinsta"},"image":{"@id":"https:\/\/kinsta.com\/it\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/kinstaitalia\/","https:\/\/x.com\/Kinsta_IT","https:\/\/www.instagram.com\/kinstahosting\/","https:\/\/www.linkedin.com\/company\/kinsta\/","https:\/\/www.pinterest.com\/kinstahosting\/","https:\/\/www.youtube.com\/c\/Kinsta"]},{"@type":"Person","@id":"https:\/\/kinsta.com\/it\/#\/schema\/person\/4eee42881d7b5a73ebb4f58dd5223b21","name":"Jeremy Holcombe","image":{"@type":"ImageObject","inLanguage":"it-IT","@id":"https:\/\/kinsta.com\/it\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/0e17001f3bb37dbbe54fceef9bb547fa?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/0e17001f3bb37dbbe54fceef9bb547fa?s=96&d=mm&r=g","caption":"Jeremy Holcombe"},"description":"Senior Editor at Kinsta, WordPress Web Developer, and Content Writer. Outside of all things WordPress, I enjoy the beach, golf, and movies. I also have tall people problems.","sameAs":["https:\/\/www.linkedin.com\/in\/jeremyholcombe\/"],"url":"https:\/\/kinsta.com\/it\/blog\/author\/jeremyholcombe\/"}]}},"acf":[],"_links":{"self":[{"href":"https:\/\/kinsta.com\/it\/wp-json\/wp\/v2\/posts\/75150","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/kinsta.com\/it\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/kinsta.com\/it\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/kinsta.com\/it\/wp-json\/wp\/v2\/users\/199"}],"replies":[{"embeddable":true,"href":"https:\/\/kinsta.com\/it\/wp-json\/wp\/v2\/comments?post=75150"}],"version-history":[{"count":7,"href":"https:\/\/kinsta.com\/it\/wp-json\/wp\/v2\/posts\/75150\/revisions"}],"predecessor-version":[{"id":75671,"href":"https:\/\/kinsta.com\/it\/wp-json\/wp\/v2\/posts\/75150\/revisions\/75671"}],"alternate":[{"embeddable":true,"hreflang":"en","title":"English","href":"https:\/\/kinsta.com\/it\/wp-json\/kinsta\/v1\/posts\/75150\/translations\/en"},{"embeddable":true,"hreflang":"pt","title":"Portuguese","href":"https:\/\/kinsta.com\/it\/wp-json\/kinsta\/v1\/posts\/75150\/translations\/pt"},{"embeddable":true,"hreflang":"fr","title":"French","href":"https:\/\/kinsta.com\/it\/wp-json\/kinsta\/v1\/posts\/75150\/translations\/fr"},{"embeddable":true,"hreflang":"de","title":"German","href":"https:\/\/kinsta.com\/it\/wp-json\/kinsta\/v1\/posts\/75150\/translations\/de"},{"embeddable":true,"hreflang":"ja","title":"Japanese","href":"https:\/\/kinsta.com\/it\/wp-json\/kinsta\/v1\/posts\/75150\/translations\/jp"},{"embeddable":true,"hreflang":"es","title":"Spanish","href":"https:\/\/kinsta.com\/it\/wp-json\/kinsta\/v1\/posts\/75150\/translations\/es"},{"embeddable":true,"hreflang":"it","title":"Italian","href":"https:\/\/kinsta.com\/it\/wp-json\/kinsta\/v1\/posts\/75150\/translations\/it"},{"href":"https:\/\/kinsta.com\/it\/wp-json\/kinsta\/v1\/posts\/75150\/tree"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/kinsta.com\/it\/wp-json\/wp\/v2\/media\/75151"}],"wp:attachment":[{"href":"https:\/\/kinsta.com\/it\/wp-json\/wp\/v2\/media?parent=75150"}],"wp:term":[{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/kinsta.com\/it\/wp-json\/wp\/v2\/tags?post=75150"},{"taxonomy":"topic","embeddable":true,"href":"https:\/\/kinsta.com\/it\/wp-json\/wp\/v2\/topic?post=75150"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}