Creazione di un'app utilizzando Serverless Framework, AWS e BigQuery

Serverless si riferisce alle applicazioni in cui la gestione e l'allocazione di server e risorse sono gestite da un provider cloud. Ciò significa che il provider cloud alloca dinamicamente le risorse. L'app è in esecuzione in un contenitore stateless che può essere attivato da un evento. Uno di questi esempi di cui sopra e quello che utilizzeremo in questo articolo riguarda AWS Lambda .

In breve, possiamo determinare le "applicazioni serverless" come applicazioni che sono sistemi basati su cloud basati su eventi. L'app si basa su servizi di terze parti, logica lato client e chiamate remote (chiamandola direttamente Function as a Service ).

Installazione di Serverless Framework e configurazione per Amazon AWS

1. Struttura senza server

Il Framework Serverless è un framework open source. Consiste in un'interfaccia a riga di comando o CLI e un dashboard ospitato, che ci fornisce un sistema di gestione delle applicazioni completamente serverless. L'utilizzo del Framework garantisce minori spese generali e costi, sviluppo e implementazione rapidi e protezione delle applicazioni serverless.

Prima di procedere con l'installazione del framework Serverless, devi prima configurare NodeJS. È molto facile da fare sulla maggior parte dei sistemi operativi: devi solo visitare il sito ufficiale di NodeJS per scaricarlo e installarlo. Ricordarsi di scegliere una versione successiva alla 6.0.0.

Dopo averlo installato, puoi confermare che NodeJS è disponibile eseguendo node -v nella console. Dovrebbe restituire la versione del nodo che hai installato:

Ora sei a posto, quindi vai avanti e installa il framework Serverless.

Per fare ciò, segui la documentazione per impostare e configurare il framework. Se preferisci, puoi installarlo solo per un progetto, ma in DevriX di solito installiamo il framework a livello globale: npm install -g serverless

Attendere il completamento del processo e assicurarsi che Serverless sia stato installato correttamente eseguendo: serverless -v

2. Crea un account Amazon AWS

Prima di procedere con la creazione dell'applicazione di esempio, devi creare un account in Amazon AWS . Se non ne hai ancora uno, è semplice come andare su Amazon AWS e fare clic su "Crea un account AWS" nell'angolo in alto a destra e seguire i passaggi per creare un account.

Amazon richiede di inserire una carta di credito, quindi non puoi procedere senza inserire tali informazioni. Al termine della registrazione e dell'accesso, dovresti vedere la Console di gestione AWS:

Grande! Procediamo ora con la creazione della tua applicazione.

3. Configura il framework serverless con il provider AWS e crea un'applicazione di esempio

In questo passaggio, dobbiamo configurare il framework Serverless con il provider AWS. Alcuni servizi come AWS Lambda richiedono credenziali quando accedi ad essi per assicurarti di disporre delle autorizzazioni per le risorse di proprietà di quel servizio. AWS consiglia di utilizzare AWS Identity and Access Manager (IAM) per farlo.

Quindi, la prima e più importante cosa è creare un utente IAM in AWS per usarlo all'interno della nostra applicazione:

Nella console AWS:

• Digita IAM nel campo "Trova servizi" .
• Fare clic su "IAM" .
• Vai su “Utenti” .
• Fai clic su "Aggiungi utente" .

Per "Nome utente" usa quello che vuoi. Ad esempio, stiamo usando serverless-admin. Per “ Tipo di accesso” spunta “Accesso programmatico” e clicca su “Autorizzazioni successive ”.

Successivamente, dobbiamo allegare le autorizzazioni per l'utente, fare clic su "Allega direttamente le politiche esistenti", cercare "Accesso amministratore" e fare clic su di esso. Procedi facendo clic su "Tag successivi"

I tag sono facoltativi, quindi puoi continuare facendo clic su "Prossima revisione" e "Crea utente". Una volta terminato e caricato, sulla pagina viene visualizzato un messaggio di successo con le credenziali di cui abbiamo bisogno.

Ora dobbiamo eseguire il seguente comando:
serverless config credentials --provider aws --key key --secret secret --profile serverless-admin
Sostituisci chiave e segreto con quelli forniti sopra. Le tue credenziali AWS vengono create come profilo. Puoi ricontrollarlo aprendo il file ~/.aws/credentials . Dovrebbe essere costituito da profili AWS. Attualmente, nell'esempio seguente, è solo uno, quello che abbiamo creato:

Ottimo lavoro finora! Puoi continuare creando un'applicazione di esempio utilizzando NodeJS e i modelli di avvio integrati.

Nota: inoltre, nell'articolo, stiamo usando il comando sls , che è l'abbreviazione di serverless .
Crea una directory vuota e inseriscila. Esegui il comando

ls create --template aws-nodejs

Usando il comando create –template , specifica uno dei modelli disponibili, in questo caso, aws-nodejs, che è un'applicazione modello NodeJS "Hello world".

Una volta terminato, la tua directory dovrebbe essere composta da quanto segue e assomigliare a questa:

Abbiamo creato i nuovi file handler.js e serverless.yml .

Il file handler.js memorizza le tue funzioni e serverless.yml memorizza le proprietà di configurazione che cambierai in seguito. Se ti stai chiedendo quale sia il file .yml , in breve, è un linguaggio di serializzazione dei dati leggibile dall'uomo . È bene conoscerlo, in quanto viene utilizzato quando si inseriscono eventuali parametri di configurazione. Ma diamo un'occhiata a ciò che abbiamo ora nel file serverless.yml :

 servizio: aws-sample-application
fornitore:
  nome: aw
  runtime: nodejs12.x
funzioni:
  Ciao:
    gestore: handler.hello

• servizio: – Il nostro nome di servizio.
• provider: – Un oggetto che contiene le proprietà del provider e, come vediamo qui, il nostro provider è AWS e stiamo utilizzando il runtime di NodeJS.
• functions: – È un oggetto che contiene tutte le funzioni che possono essere distribuite in Lambda. In questo esempio, abbiamo solo una funzione denominata hello che punta alla funzione hello di handler.js.

Devi fare una cosa cruciale qui prima di procedere con la distribuzione dell'applicazione. In precedenza, abbiamo impostato le credenziali per AWS con un profilo (l'abbiamo chiamato serverless-admin ). Ora tutto ciò che devi fare è dire alla configurazione serverless di utilizzare quel profilo e la tua regione. Apri serverless.yml e sotto la proprietà del provider sotto il runtime inserisci questo:

 profilo: serverless-admin
regione: us-est-2

Alla fine, dovremmo avere questo:

 fornitore:
  nome: aw
  runtime: nodejs12.x
  profilo: serverless-admin
  regione: us-est-2

Nota: per ottenere la regione, un modo semplice è cercare l'URL dopo aver effettuato l'accesso alla console: Esempio:

Ora che abbiamo le informazioni necessarie sul nostro modello generato. Verifichiamo come possiamo richiamare la funzione in locale e distribuirla in AWS Lambda.
Possiamo immediatamente testare l'applicazione invocando localmente la funzione:

sls invoke local -f hello

Invoca la funzione (ma solo localmente!) E restituisce l'output alla console:

Ora, se tutto è andato bene, puoi provare a distribuire la tua funzione su AWS Lambda .

Allora, è stato complicato? No, non lo era! Grazie al Serverless Framework è solo un codice di una riga:

sls deploy -v

Aspetta che tutto finisca, potrebbero volerci alcuni minuti, se tutto è a posto dovresti finire con qualcosa del genere:

Ora controlliamo cosa è successo in AWS. Vai a Lambda (in " Trova servizi " digita Lambda ) e dovresti vedere la tua funzione Lambda creata.

Ora puoi provare a richiamare la tua funzione da AWS Lambda. Nel tipo di terminale
sls invoke -f hello
Dovrebbe restituire lo stesso output di prima (quando testiamo localmente):

Puoi verificare di aver attivato la funzione di AWS aprendo la funzione in AWS Lambda e andando alla scheda " Monitoraggio " e facendo clic su " Visualizza log in CloudWatch. “.

Dovresti avere un registro lì.

Ora, nella tua applicazione manca ancora una cosa, ma che cos'è...? Bene, non hai un endpoint a cui accedere per la tua app, quindi creiamolo utilizzando AWS API Gateway.

Devi prima aprire il file serverless.yml e ripulire i commenti. Devi aggiungere una proprietà events alla nostra funzione e sotto la sua proprietà http . Ciò indica al framework Serverless di creare un gateway API e di collegarlo alla nostra funzione Lambda durante la distribuzione dell'app. Il nostro file di configurazione dovrebbe terminare in questo:

 servizio: aws-sample-application
fornitore:
  nome: aw
  runtime: nodejs12.x
  profilo: serverless-admin
  regione: us-est-2
funzioni:
  Ciao:
    gestore: handler.hello
    eventi:
      - http:
          percorso: /ciao
          metodo: ottenere

In http specifichiamo il percorso e il metodo HTTP.
Ecco fatto, distribuiamo nuovamente la nostra app eseguendo sls deploy -v

Una volta terminato, dovrebbe apparire una nuova cosa nel terminale di output, e questo è l'endpoint che è stato creato:

Apriamo l'endpoint:

Dovresti vedere che la tua funzione è in esecuzione, restituisce output e alcune informazioni sulla richiesta. Verifichiamo cosa sta cambiando nella nostra funzione Lambda.

Apri AWS Lambda e fai clic sulla tua funzione.

Vediamo nella scheda " Designer " che abbiamo API Gateway collegato al nostro Lambda e all'API Endpoint.

Grande! Hai creato un'applicazione serverless semplicissima, l'hai distribuita in AWS Lambda e ne hai testato la funzionalità. Inoltre, abbiamo aggiunto un endpoint utilizzando AWS API Gateway .

4. Come eseguire l'applicazione offline

Finora, sappiamo che possiamo invocare funzioni localmente, ma possiamo anche eseguire la nostra intera applicazione offline utilizzando il plug-in serverless-offline.

Il plug-in emula AWS Lambda e API Gateway sulla tua macchina locale/di sviluppo. Avvia un server HTTP che gestisce le richieste e richiama i tuoi gestori.

Per installare il plugin, esegui il comando seguente nella directory dell'app

npm install serverless-offline --save-dev

Quindi all'interno del serverless.yml del progetto apri il file e aggiungi la proprietà dei plugin :

 plugin:
  - serverless-offline

La configurazione dovrebbe assomigliare a questa:

 servizio: aws-sample-application
fornitore:
  nome: aw
  runtime: nodejs12.x
  profilo: serverless-admin
  regione: us-est-2
funzioni:
  Ciao:
    gestore: handler.hello
    eventi:
      - http:
          percorso: /ciao
          metodo: ottenere
plugin:
  - serverless-offline

Per verificare di aver installato e configurato correttamente il plugin, esegui

sls --verbose

Dovresti vedere questo:

Ora nella radice del tuo progetto, esegui il comando

sls offline

Come puoi vedere, un server HTTP è in ascolto sulla porta 3000 e puoi accedere alle tue funzioni, ad esempio, qui abbiamo http://localhost:3000/dev/hello per la nostra funzione ciao. Aprendo questo abbiamo la stessa risposta di API Gateway , che abbiamo creato in precedenza.

Aggiungi l'integrazione di Google BigQuery

Hai fatto un ottimo lavoro finora! Hai un'applicazione completamente funzionante che utilizza Serverless. Estendiamo la nostra app e aggiungiamo l'integrazione BigQuery per vedere come funziona e come viene eseguita l'integrazione.

BigQuery è un Software as a Service (SaaS) serverless, ovvero un data warehouse economico e veloce che supporta le query. Prima di continuare a integrarlo con la nostra app NodeJS, dobbiamo creare un account, quindi procediamo.

1. Configura Google Cloud Console

Vai su https://cloud.google.com e accedi con il tuo account, se non l'hai già fatto – crea un account e procedi.

Quando accedi a Google Cloud Console, devi creare un nuovo progetto. Fai clic sui tre punti accanto al logo e si aprirà una finestra modale in cui scegli " Nuovo progetto. "

Inserisci un nome per il tuo progetto. Useremo bigquery-example . Dopo aver creato il progetto, accedi a BigQuery utilizzando il drawer:

Quando BigQuery viene caricato, sul lato sinistro vedrai i dati del progetto, a cui hai accesso, e anche i set di dati pubblici. Stiamo usando un set di dati pubblico per questo esempio. Si chiama covid19_ecdc :

Gioca con il set di dati e le tabelle disponibili. Visualizza in anteprima i dati in esso contenuti. Si tratta di un set di dati pubblico che viene aggiornato ogni ora e contiene informazioni sui dati di COVID-19 in tutto il mondo.

Dobbiamo creare un utente IAM -> Account di servizio per poter accedere ai dati. Quindi, nel menu, fai clic su "IAM e amministratore", quindi su "Account di servizio".

Fare clic sul pulsante "Crea account di servizio" , immettere il nome dell'account di servizio e fare clic su "Crea". Quindi, vai su " Autorizzazioni account di servizio" , cerca e scegli "Amministrazione BigQuery" .

Fai clic su " Continua ", questo è l'ultimo passaggio, qui hai bisogno delle tue chiavi, quindi fai clic sul pulsante di creazione in " Chiavi " ed esporta come JSON . Salvalo da qualche parte in modo sicuro, ne avremo bisogno in seguito. Fare clic su Fine per completare la creazione dell'account di servizio.

Ora utilizzeremo le credenziali generate qui per connettere la libreria NodeJS BigQuery.

2. Installa la libreria BigQuery di NodeJS

Dovrai installare la libreria BigQuery NodeJS per usarla nel progetto che hai appena creato. Esegui i comandi seguenti nella directory dell'app:

Innanzitutto, inizializza npm eseguendo npm init

Rispondi a tutte le domande e procedi con l'installazione della libreria BigQuery :
npm install @google-cloud/bigquery

Prima di continuare a modificare il nostro gestore di funzioni, dobbiamo trasportare la chiave privata dal file JSON che abbiamo creato in precedenza. Utilizzeremo le variabili di ambiente Serverless per farlo. Puoi ottenere maggiori informazioni qui.

Apri serverless.yml e nella proprietà del provider aggiungi la proprietà dell'ambiente in questo modo:

 ambiente:
PROJECT_ID: ${file(./config/bigquery-config.json):project_id}
CLIENT_EMAIL: ${file(./config/bigquery-config.json):client_email}
PRIVATE_KEY: ${file(./config/bigquery-config.json):private_key}

Crea variabili di ambiente PROJECT_ID , PRIVATE_KEY e CLIENT_EMAIL , che prendono le stesse proprietà (minuscole) dal file JSON che abbiamo generato. Lo abbiamo inserito nella cartella config e l'abbiamo chiamato bigquery-config.json .

In questo momento, dovresti finire con il file serverless.yml simile a questo:

 servizio: aws-sample-application
fornitore:
  nome: aw
  runtime: nodejs12.x
  profilo: serverless-admin
  regione: us-est-2
  ambiente:
    PROJECT_ID: ${file(./config/bigquery-config.json):project_id}
    CLIENT_EMAIL: ${file(./config/bigquery-config.json):client_email}
    PRIVATE_KEY: ${file(./config/bigquery-config.json):private_key}
funzioni:
  Ciao:
    gestore: handler.hello
    eventi:
      - http:
          percorso: /ciao
          metodo: ottenere
plugin:
  - serverless-offline

Ora apri handler.js e lascia che importi la libreria BigQuery, nella parte superiore del file in "use strict" aggiungi la seguente riga:

const {BigQuery} = require('@google-cloud/bigquery');

Ora dobbiamo comunicare le credenziali alla libreria BigQuery. A tale scopo, crea una nuova costante che istanzia BigQuery con le credenziali:

 const bigQueryClient = nuovo BigQuery({
    ID progetto: process.env.PROJECT_ID,
    credenziali: {
        client_email: process.env.CLIENT_EMAIL,
        chiave_privata: process.env.PRIVATE_KEY
    }
});

Quindi, creiamo la nostra query SQL BigQuery. Vogliamo recuperare le ultime informazioni sui casi di COVID-19 in Bulgaria. Utilizziamo l'editor di query BigQuery per testarlo prima di procedere, quindi abbiamo creato una query personalizzata:

 SELEZIONA * DA `bigquery-public-data.covid19_ecdc.covid_19_geographic_distribution_worldwide` DOVE geo_ ORDINA PER data DESC LIMITE 1 

Bene! Ora implementiamolo nella nostra app NodeJS.
Apri handler.js e incolla il codice qui sotto

 const query = 'SELECT * FROM `bigquery-public-data.covid19_ecdc.covid_19_geographic_distribution_worldwide` WHERE geo_id = \'BG\' ORDINA PER data DESC LIMITE 1';
opzioni cost = {
    domanda: domanda
}

const [lavoro] = attendi bigQueryClient.createQueryJob(opzioni);
const [righe] = attendi job.getQueryResults();

Abbiamo creato costanti di query e opzioni . Quindi procediamo con l'esecuzione della query come un lavoro e il recupero dei risultati da esso.

Cambiamo anche il nostro gestore di ritorno per restituire le righe generate dalla query:

 Restituzione {
    codice di stato: 200,
    corpo: JSON.stringify(
        {
            righe
        },
        nullo,
        2
    ),
};

Vediamo il handler.js completo:

 'usare rigorosamente';

const {BigQuery} = require('@google-cloud/bigquery');
const bigQueryClient = nuovo BigQuery({
    ID progetto: process.env.PROJECT_ID,
    credenziali: {
        client_email: process.env.CLIENT_EMAIL,
        chiave_privata: process.env.PRIVATE_KEY
    }
});

module.exports.hello = evento asincrono => {
    const query = 'SELECT * FROM `bigquery-public-data.covid19_ecdc.covid_19_geographic_distribution_worldwide` WHERE geo_id = \'BG\' ORDINA PER data DESC LIMITE 1';
    opzioni cost = {
        domanda: domanda
    }

    const [lavoro] = attendi bigQueryClient.createQueryJob(opzioni);
    const [righe] = attendi job.getQueryResults();

    Restituzione {
        codice di stato: 200,
        corpo: JSON.stringify(
            {
                righe
            },
            nullo,
            2
        ),
    };
};

Bene! Testiamo la nostra funzione localmente:
sls invoke local -f hello
Dovremmo vedere l'output:

Procedere con la distribuzione dell'applicazione per testarla tramite gli endpoint HTTP, quindi eseguire sls deploy -v

Attendi che finisca e apri l'endpoint. Ecco i risultati:

Molto bene! Ora abbiamo un'applicazione per recuperare i dati da BigQuery e restituire una risposta! Controlliamo infine che funzioni offline. Esegui sls offline

E carica l'endpoint locale:

Lavoro ben fatto. Siamo quasi alla fine del processo. L'ultimo passaggio consiste nel modificare leggermente l'app e il comportamento. Invece di AWS API Gateway , vogliamo utilizzare Application Load Balancer . Vediamo come raggiungerlo nel prossimo capitolo.

ALB – Application Load Balancer in AWS

Abbiamo creato la nostra applicazione utilizzando AWS API Gateway. In questo capitolo tratteremo come sostituire il gateway API con Application Load Balancer (ALB).

Per prima cosa, vediamo come funziona il servizio di bilanciamento del carico dell'applicazione rispetto al gateway API:

In Application Load Balancer, mappiamo uno o più percorsi specifici (ad es. /hello/ ) a un gruppo target: un gruppo di risorse, nel nostro caso, la funzione Lambda .

Un gruppo target può avere solo una funzione Lambda associata. Ogni volta che il gruppo di destinazione deve rispondere, il sistema di bilanciamento del carico dell'applicazione invia una richiesta a Lambda e la funzione deve rispondere con un oggetto risposta. Come il gateway API, l' ALB gestisce tutte le richieste HTTP.

Esistono alcune differenze tra l'ALB e l' API Gateway . Una differenza principale è che API Gateway supporta solo HTTPS (SSL), mentre l'ALB supporta sia HTTP che HTTPS.

Ma vediamo alcuni pro e contro dell'API Gateway:

Gateway API:

Professionisti:

• Sicurezza eccellente.
• È semplice da implementare.
• È veloce per la distribuzione ed è pronto per l'uso in un minuto.
• Scalabilità e disponibilità.

Contro:

• Può diventare piuttosto costoso di fronte a un traffico intenso.
• Richiede un po' più di orchestrazione, che aggiunge un livello di difficoltà per gli sviluppatori.
• Il degrado delle prestazioni, dovuto agli scenari API, può influire sulla velocità e sull'affidabilità dell'applicazione.

Continuiamo con la creazione di un ALB e il passaggio ad esso invece di utilizzare API Gateway:

1. Che cos'è ALB?

Il servizio di bilanciamento del carico dell'applicazione consente allo sviluppatore di configurare e instradare il traffico in entrata. È una funzionalità di " Elastic Load Balancing". Funge da unico punto di contatto per i clienti, distribuisce il traffico delle applicazioni in entrata su più destinazioni, come le istanze EC2 in più zone.

2. Crea un Application Load Balancer utilizzando l'interfaccia utente di AWS

Creiamo il nostro Application Load Balancer (ALB) tramite l'interfaccia utente in Amazon AWS. Accedi alla Console AWS in " Trova servizi. ” digita “ EC2 ” e trova “ Load Balancers. "

Fai clic su " Crea Load Balancer ", in " Application Load Balancer ", scegli " Crea ". Per un nome, inserisci la tua scelta, abbiamo usato " sample-alb ", scegli Schema " con connessione a Internet ", tipo di indirizzo IP ipv4.

Su " Listeners ", lascialo così com'è: HTTP e porta 80. Può essere configurato per HTTPS, anche se devi avere un dominio e confermarlo prima di poter utilizzare HTTPS.

Zone di disponibilità: per VPC scegli quella che hai dal menu a discesa e contrassegna tutte le " Zone di disponibilità" :

Fare clic su " Avanti Configura impostazioni di sicurezza " per richiedere di migliorare la sicurezza del sistema di bilanciamento del carico. Fare clic su Avanti.

Al " Passaggio 3. Configura gruppi di sicurezza ", in Assegna un gruppo di sicurezza per scegliere "Crea un nuovo gruppo di sicurezza". Procedi facendo clic su " Avanti: Configura Routing. “. Al passaggio 4 configuralo come mostrato nello screenshot sopra:

Fare clic su Avanti , Avanti e Crea .

Torna ai sistemi di bilanciamento del carico e copia l'ARN come mostrato nello screenshot:

Ora dobbiamo cambiare il nostro serverless.yml e rimuovere la proprietà http di API Gateway. Nella proprietà events, rimuovi la proprietà http e aggiungi una proprietà alb. L'oggetto funzione dovrebbe terminare in questo modo:

 Ciao:
  gestore: handler.hello
  eventi:
    - camice:
        listenerArn: arn:aws:elasticloadbalancing:us-east-2:115129174008:listener/app/sample-alb/ae6e398a898c48e6/67ce6bf319d0513d
        priorità: 1
        condizioni:
          percorso: /ciao

Salvare il file ed eseguire il comando per la distribuzione dell'applicazione
sls deploy -v

Dopo aver distribuito correttamente, torna ad AWS Load Balancer e trova il tuo nome DNS come mostrato nello screenshot:

Copia il nome DNS e inserisci path /hello .

Dovrebbe funzionare e alla fine offrirti la possibilità di scaricare contenuti :). Finora, il sistema di bilanciamento del carico dell'applicazione funziona meravigliosamente, ma l'applicazione deve restituire una risposta adeguata per i nostri utenti finali. Per fare ciò, apri handler.js e sostituisci l'istruzione di ritorno con quella seguente:

 Restituzione {
    codice di stato: 200,
    statusDescrizione: "200 OK",
    intestazioni: {
        "Tipo di contenuto": "applicazione/json"
    },
    isBase64Encoded: false,
    corpo: JSON.stringify(righe)
}

La differenza dell'ALB è che la risposta deve includere container statusDescription, headers e isBase64Encoded. Salva il file e distribuiscilo di nuovo, ma questa volta non l'intera applicazione, ma solo la funzione che abbiamo modificato. Esegui il comando seguente:
sls deploy -f hello

In questo modo, stiamo definendo solo la funzione ciao da distribuire. Dopo aver distribuito correttamente, visita di nuovo il nome DNS con il percorso e dovresti avere una risposta corretta!

Grande! Ora abbiamo sostituito API Gateway con Application Load Balancer. Il bilanciamento del carico dell'applicazione è più economico del gateway API e ora possiamo estendere la nostra applicazione per soddisfare le nostre esigenze, soprattutto se prevediamo di avere un traffico maggiore.

Parole finali

Abbiamo creato una semplice applicazione utilizzando Serverless Framework, AWS e BigQuery e ne abbiamo coperto l'utilizzo principale. Il serverless è il futuro ed è facile gestire un'applicazione con esso. Continua ad imparare e tuffati nel framework Serverless per esplorare tutte le sue funzionalità e i segreti che ha. È anche uno strumento piuttosto semplice e conveniente.