Invio di email con SendGrid

Questo tutorial mostra come utilizzare SendGrid per inviare email da un'app in esecuzione su un'istanza di macchina virtuale (VM) Compute Engine.

Obiettivi

Utilizzare SendGrid con Postfix su un'istanza di Compute Engine.
Usa SendGrid nel codice Java in esecuzione su un'istanza di Compute Engine.
Usa SendGrid nel codice Node.js in esecuzione su un'istanza Compute Engine.
Utilizzare SendGrid con un server di trasporto perimetrale di Microsoft Exchange su un'istanza di Compute Engine.

Per altre informazioni sulla configurazione di SendGrid, consulta la documentazione per gli sviluppatori di SendGrid.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Compute Engine

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono essere idonei a una prova senza costi aggiuntivi.

Prima di iniziare

Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Nella console Google Cloud, vai alla pagina Crea un'istanza.
Vai a Crea un'istanza
Imposta Nome su sendgrid-tutorial.
Nella sezione Disco di avvio, fai clic su Cambia per iniziare a configurare il disco di avvio.

Nella scheda Public images, scegli a Debian or CentOS image version.
Fai clic su Seleziona.
Per creare la VM, fai clic su Crea.

Utilizza Google Cloud Marketplace per registrarti al servizio email SendGrid. Prendi nota delle credenziali dell'account SMTP di SendGrid, che includono nome utente, password e nome host. Il nome utente e la password SMTP corrispondono a quelli che hai utilizzato per registrarti al servizio. Il nome host di SendGrid è smtp.sendgrid.net.
Crea una chiave API:
1. Accedi a SendGrid e vai a Impostazioni > Chiavi API.
2. Creare una chiave API.
3. Seleziona le autorizzazioni per la chiave. Per inviare email, la chiave deve disporre almeno delle autorizzazioni Invio tramite posta.
4. Fai clic su Salva per creare la chiave.
5. SendGrid genera una nuova chiave. Questa è l'unica copia della chiave, quindi assicurati di copiare la chiave e di salvarla per un secondo momento.

Invio di posta dalla tua istanza con Postfix

Completa i seguenti passaggi per connetterti alla tua istanza sendgrid-tutorial ed eseguire SendGrid con Postfix.

Connettiti alla tua istanza sendgrid-tutorial utilizzando SSH

Nella console Google Cloud, vai alla pagina Istanze VM.
Vai a Istanze VM
Nell'elenco delle istanze di macchine virtuali, fai clic su SSH nella riga dell'istanza a cui vuoi connetterti.

Configurare SendGrid come inoltro SMTP con Postfix

Esegui i comandi seguenti nel terminale SSH per utilizzare SendGrid come inoltro SMTP con Postfix.

Diventa un super user:
```
sudo su -
```
Imposta un umask sicuro:
```
umask 077
```
Installa Postfix Mail Transport Agent:
Debian
```
apt update && apt -y install postfix libsasl2-modules
```
CentOS
```
yum install postfix cyrus-sasl-plain cyrus-sasl-md5 -y
```
Se richiesto, seleziona la configurazione Solo locale e accetta il nome di dominio predefinito.
Modificare le opzioni di configurazione di Postfix. Apri /etc/postfix/main.cf per la modifica. Ad esempio, per utilizzare l'editor di testo nano, inserisci il seguente comando:
```
nano /etc/postfix/main.cf
```
Aggiorna il file:
1. Commenta le seguenti righe:
```
# default_transport = error
# relay_transport = error
```
2. Aggiungi le seguenti righe alla fine del file:
```
relayhost = [smtp.sendgrid.net]:2525
smtp_tls_security_level = encrypt
smtp_sasl_auth_enable = yes
smtp_sasl_password_maps = hash:/etc/postfix/sasl_passwd
header_size_limit = 4096000
smtp_sasl_security_options = noanonymous
```
  Le righe precedenti applicano il supporto SSL/TLS e configurano l'autenticazione SMTP per queste richieste. Un modulo SASL (Access and Security Layer) semplice gestisce l'autenticazione nella configurazione di Postfix.
Salva e chiudi il file.
Genera la mappa delle password SASL utilizzando la chiave API generata nella sezione Prima di iniziare. Sostituisci your-api-key con la chiave API che hai generato.
```
echo [smtp.sendgrid.net]:2525 apikey:your-api-key >> /etc/postfix/sasl_passwd
```
Usa l'utilità postmap per generare un file .db:
```
postmap /etc/postfix/sasl_passwd
```

Verifica di avere un file .db:

ls -l /etc/postfix/sasl_passwd*

-rw------- 1 root root    ...  /etc/postfix/sasl_passwd
-rw------- 1 root root    ...  /etc/postfix/sasl_passwd.db

Rimuovi il file contenente le tue credenziali perché non è più necessario:
```
rm /etc/postfix/sasl_passwd
```

Imposta le autorizzazioni per il tuo file .db e verifica che l'altro file sia stato rimosso:

chmod 600 /etc/postfix/sasl_passwd.db
ls -la /etc/postfix/sasl_passwd*

-rw------- 1 root root    ...  /etc/postfix/sasl_passwd.db

Ricarica la configurazione per caricare i parametri modificati:
Debian
```
/etc/init.d/postfix restart
```
CentOS
```
postfix reload
```
Installa il pacchetto mailutils o mailx:
Debian
```
apt -y install mailutils
```
CentOS
```
yum install mailx -y
```
Invia un'email di prova:
```
echo 'message' | mail -s subject email@example.com
```
Sostituisci quanto segue:
- message: il corpo dell'email.
- subject: l'oggetto dell'email.
- email@example.com: l'indirizzo email a cui vuoi inviare un messaggio.
Nei log di sistema cerca una riga di stato contenente status e il codice di risposta del server riuscito (250):
Debian
```
tail -n 5 /var/log/syslog
```
CentOS
```
tail -n 5 /var/log/maillog
```

Invio di posta con Java sulla tua istanza

Connettiti alla tua istanza sendgrid-tutorial utilizzando SSH

Nella console Google Cloud, vai alla pagina Istanze VM.
Vai a Istanze VM
Nell'elenco delle istanze di macchine virtuali, fai clic su SSH nella riga dell'istanza a cui vuoi connetterti.

Costruire e inviare un messaggio email

Le seguenti istruzioni utilizzano la libreria client Java di SendGrid per creare e inviare un messaggio email tramite SendGrid. Puoi visualizzare l'esempio completo su GitHub.

Nel terminale SSH:

Diventa un super user e imposta un umask sicuro:
```
sudo su -
umask 077
```

Installa Java e Maven:

apt -y update && apt -y install git-core openjdk-11-jdk maven

Clona il repository GitHub:

git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git

Vai al codice sorgente principale per l'esempio:

cd /root/java-docs-samples/compute/sendgrid/src/main/java/com/example/compute/sendgrid

Apri SendEmailServelet.java per la modifica.
- Sostituisci your-sendgrid-api-key con la chiave API per il tuo account SendGrid.
- Sostituisci your-sendgrid-from-email con l'indirizzo email da cui vuoi inviare la posta.
- Sostituisci destination-email con l'indirizzo email a cui vuoi inviare la posta.
Vai alla directory radice del codice campione:
```
cd /root/java-docs-samples/compute/sendgrid
```
Crea un pacchetto della classe Java:
```
mvn clean package
```
Vai alla nuova directory target:
```
cd target
```
Imposta le autorizzazioni che ti consentono di eseguire il file jar:
```
chmod +x compute-sendgrid-1.0-SNAPSHOT-jar-with-dependencies.jar
```
Esegui il selettore della versione Java alternativa:
```
update-alternatives --config java
```
Seleziona l'opzione java-11-openjdk-amd64.

Esegui il file Java:

java -jar compute-sendgrid-1.0-SNAPSHOT-jar-with-dependencies.jar

Invio di posta con Node.js sulla tua istanza

Per eseguire questo esempio, devi aver installato Node.js versione 7.6 o successiva sull'istanza VM.

Connettiti alla tua istanza sendgrid-tutorial utilizzando SSH

Nella console Google Cloud, vai alla pagina Istanze VM.
Vai a Istanze VM
Nell'elenco delle istanze di macchine virtuali, fai clic su SSH nella riga dell'istanza a cui vuoi connetterti.

Costruire e inviare un messaggio email

Nel terminale SSH:

Diventa un super user e imposta un umask sicuro:
```
sudo su -
umask 077
```
Aggiorna i repository dei pacchetti:
Debian
```
apt update
```
CentOS
```
yum update -y
```

Installa le dipendenze Node.js:

Debian

apt -y install git-core curl build-essential openssl libssl-dev

CentOS

yum install git-core curl openssl openssl-devel -y
yum groupinstall "Development Tools" -y

Installa Node.js. Per impostazione predefinita, l'installazione installa anche npm:

Debian

curl -sL https://deb.nodesource.com/setup_14.x | sudo bash -
sudo apt -y install nodejs

CentOS

curl --silent --location https://rpm.nodesource.com/setup_14.x | bash -

Quindi, installa Node.js:

yum -y install nodejs

Installa il client Node.js SendGrid:
```
npm install sendgrid
```

Clona il repository di esempio:

git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git

Vai alla directory che contiene l'esempio di SendGrid:
```
cd nodejs-docs-samples/compute
```
Copia il file sendgrid.js:
```
cp sendgrid.js sendmail.js
```

Apri sendmail.js per la modifica.

Sostituisci your-sendgrid-api-key con la chiave API per il tuo account SendGrid.
Sostituisci from-email@example.com con l'indirizzo email da cui vuoi inviare la posta.
Sostituisci to-email@example.com con l'indirizzo email a cui vuoi inviare la posta.

// This sample is based off of:
// https://github.com/sendgrid/sendgrid-nodejs/tree/master/packages/mail
const sendgrid = require('@sendgrid/mail');
sendgrid.setApiKey(process.env.SENDGRID_API_KEY || '<your-sendgrid-api-key>');

async function sendgridExample() {
  await sendgrid.send({
    to: 'to_email@example.com',
    from: 'from_email@example.com',
    subject: 'Sendgrid test email from Node.js on Google Cloud Platform',
    text: 'Well hello! This is a Sendgrid test email from Node.js on Google Cloud Platform.',
  });
}
sendgridExample();

Esegui il programma per inviare un messaggio e-mail tramite SendGrid:
```
node sendmail.js
```

Invio di posta da un server di trasporto perimetrale di Exchange

Puoi impostare Microsoft Exchange per l'invio di email in uscita con SendGrid configurando un connettore di invio in uscita. Per maggiori dettagli, consulta Deployment di Microsoft Exchange Server 2016 su Compute Engine.

Esegui la pulizia

Per evitare che al tuo Account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione è eliminare il progetto che hai creato per il tutorial.

Per eliminare il progetto:

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

Nella console Google Cloud, vai alla pagina Gestisci risorse.
Vai a Gestisci risorse
Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Elimina l'istanza Compute Engine

Per eliminare un'istanza di Compute Engine:

Nella console Google Cloud, vai alla pagina Istanze VM.
Vai a Istanze VM
Seleziona la casella di controllo per la tua istanza sendgrid-tutorial.
Per eliminare l'istanza, fai clic su Altre azioni, quindi su Elimina e segui le istruzioni.

Passaggi successivi

Esplora le architetture di riferimento, i diagrammi e le best practice su Google Cloud. Visita il nostro Cloud Architecture Center.