Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Configurazione del protocollo HTTPS per l'ambiente Elastic Beanstalk
Gli argomenti di questa sezione spiegano come configurare HTTPS per l'ambiente Elastic Beanstalk. Il protocollo HTTPS è obbligatorio per tutte le applicazioni che trasmettono i dati utente o le informazioni di accesso.
Se hai acquistato e configurato un [nome di dominio personalizzato](customdomains.md) per l'ambiente Elastic Beanstalk, puoi utilizzare il protocollo HTTPS per permettere agli utenti di collegarsi al tuo sito Web in modo sicuro.
Se non possiedi un nome di dominio, puoi comunque utilizzare il protocollo HTTPS con un certificato autofirmato a scopo di sviluppo e test. Per ulteriori informazioni, consulta [Certificati server](configuring-https.certificate.md).
**Configurazione della terminazione HTTPS sul sistema di bilanciamento del carico**
Un load balancer distribuisce le richieste alle istanze EC2 che eseguono l'applicazione. Un sistema di bilanciamento del carico inoltre elimina la necessità di esporre le proprie istanze direttamente in Internet. Il modo più semplice per utilizzare HTTPS con un ambiente multiistanza Elastic Beanstalk consiste nel configurare un listener sicuro per il load balancer. La connessione tra il client e il sistema di bilanciamento del carico rimane sicura, quindi puoi configurare il load balancer per terminare HTTPS. Le connessioni back-end tra il load balancer e le istanze EC2 utilizzano HTTP, quindi non è richiesta alcuna configurazione aggiuntiva delle istanze. Per istruzioni dettagliate su come configurare un listenter sicuro, consulta. [Configurazione della terminazione HTTPS sul sistema di bilanciamento del carico](configuring-https-elb.md)
**Configurazione della terminazione HTTPS sull'istanza EC2**
Se esegui l'applicazione in un ambiente a istanza singola o se intendi proteggere l'intera connessione alle istanze EC2 che usano il sistema di bilanciamento del carico, puoi configurare il server proxy in esecuzione nell'istanza per terminare il protocollo HTTPS. La configurazione delle istanze per terminare le connessioni HTTPS richiede l'uso di [file di configurazione](ebextensions.md) per modificare il software in esecuzione nelle istanze e i gruppi di sicurezza al fine di permettere le connessioni sicure. Per ulteriori informazioni, consulta [Configurazione della terminazione HTTPS sull'istanza](https-singleinstance.md).
**Configurazione di HTTPS end-to-end**
Per end-to-end HTTPS in un ambiente con bilanciamento del carico, puoi combinare la terminazione dell'istanza e del load balancer per crittografare entrambe le connessioni. Per impostazione predefinita, se configuri il sistema di bilanciamento del carico per inoltrare il traffico tramite HTTPS, quest'ultimo considererà attendibile qualsiasi certificato presentato dalle istanze back-end. Per la massima sicurezza, puoi collegare policy al sistema di bilanciamento del carico per impedire la connessione alle istanze che non dispongono di un certificato pubblico considerato attendibile. Per ulteriori informazioni, consulta [Configurazione della end-to-end crittografia in un ambiente Elastic Beanstalk con carico bilanciato](configuring-https-endtoend.md).
**Configurazione di HTTPS con TCP Passthrough**
È inoltre possibile configurare il sistema di bilanciamento del carico per l'inoltro del traffico HTTPS senza decrittografarlo. Per ulteriori informazioni, consulta [Configurazione del sistema di bilanciamento del carico dell'ambiente per il passthrough TCP](https-tcp-passthrough.md).
**Nota**
Il [Ha serpenti](https://github.com/awslabs/eb-tomcat-snakes)? l'applicazione di esempio GitHub include file di configurazione e istruzioni per ogni metodo di configurazione HTTPS con un'applicazione web Tomcat. Consulta il [file readme](https://github.com/awslabs/eb-tomcat-snakes/blob/master/README.md) e le [istruzioni relative ad HTTPS](https://github.com/awslabs/eb-tomcat-snakes/blob/master/src/.ebextensions/inactive/HTTPS.md) per i dettagli.
**Topics**
+ [
# Certificati server
](configuring-https.certificate.md)
+ [
# Configurazione della terminazione HTTPS sul sistema di bilanciamento del carico
](configuring-https-elb.md)
+ [
# Configurazione della terminazione HTTPS sull'istanza
](https-singleinstance.md)
+ [
# Configurazione della end-to-end crittografia in un ambiente Elastic Beanstalk con carico bilanciato
](configuring-https-endtoend.md)
+ [
# Configurazione del sistema di bilanciamento del carico dell'ambiente per il passthrough TCP
](https-tcp-passthrough.md)
+ [
# Configurazione del reindirizzamento da HTTP a HTTPS
](configuring-https-httpredirect.md)
# Certificati server
Questo argomento descrive i diversi tipi di certificati che è possibile utilizzare per configurare HTTPS e quando applicarli. Gli argomenti secondari di questa sezione forniscono istruzioni per creare il proprio certificato e come caricarlo.
**AWS Certificate Manager (ACM)**
ACM è lo strumento preferito per il provisioning, la gestione e la distribuzione dei certificati del server. È possibile farlo a livello di codice o utilizzando. AWS CLI Con ACM puoi creare gratuitamente un certificato affidabile per i tuoi nomi di dominio.
I certificati ACM possono essere utilizzati solo con sistemi di bilanciamento del AWS carico e CloudFront distribuzioni Amazon e ACM è disponibile solo in alcune regioni. AWS Per utilizzare un certificato ACM con Elastic Beanstalk, consulta [Configurazione della terminazione HTTPS sul sistema di bilanciamento del carico](configuring-https-elb.md). [https://docs.aws.amazon.com/acm/latest/userguide/acm-overview.html](https://docs.aws.amazon.com/acm/latest/userguide/acm-overview.html)
**Nota**
Per un elenco delle regioni in cui è disponibile ACM, consulta [Endpoint e quote ACM](https://docs.aws.amazon.com/general/latest/gr/acm.html) nel. *Riferimenti generali di Amazon Web Services*
Se ACM non è disponibile nella tua AWS regione, puoi caricare un certificato di terze parti o autofirmato e una chiave privata su (IAM). AWS Identity and Access Management Puoi utilizzare il AWS CLI per caricare il certificato. I certificati archiviati in IAM possono essere utilizzati con sistemi di bilanciamento del carico e CloudFront distribuzioni. Per ulteriori informazioni, consulta [Caricamento di un certificato in IAM](configuring-https-ssl-upload.md).
**Certificato di terze parti**
Se ACM non è disponibile nella tua regione, puoi acquistare un certificato attendibile da una terza parte. Puoi utilizzare un certificato di terze parti per decrittografare il traffico HTTPS a livello di sistema di bilanciamento del carico e/o delle istanze back-end.
**Certificato autofirmato**
Per i processi di sviluppo e test, puoi [creare e firmare un certificato](configuring-https-ssl.md) utilizzando strumenti open source. I certificati autofirmati sono gratuiti e semplici da creare, ma non possono essere utilizzati per la decrittografia front-end nei siti pubblici. Se tenti di utilizzare un certificato autofirmato per una connessione HTTPS a un client, il browser dell'utente mostra un messaggio di errore che indica che il sito Web non è sicuro. Puoi, tuttavia, utilizzare un certificato autofirmato per proteggere le connessioni back-end senza alcun problema.
# Creazione e firma di un certificato X509
Puoi creare un certificato X509 per la tua applicazione con `OpenSSL`. OpenSSL è una libreria open source standard che supporta un'ampia gamma di funzioni di crittografia, tra cui la creazione e la firma di certificati X509. Per ulteriori informazioni su OpenSSL, visita la pagina Web all'indirizzo [www.openssl.org](https://www.openssl.org/).
**Nota**
È sufficiente creare un certificato in locale se si desidera [utilizzare HTTPS in un ambiente a istanza singola](https-singleinstance.md) o [eseguire nuovamente la crittografia al back-end](configuring-https-endtoend.md) con un certificato autofirmato. Se possiedi un nome di dominio, puoi creare un certificato AWS e utilizzarlo gratuitamente in un ambiente con bilanciamento del carico utilizzando AWS Certificate Manager (ACM). Per istruzioni, consulta la pagina relativa alla [richiesta di un certificato](https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request.html) nella *Guida per l'utente di AWS Certificate Manager *.
Esegui `openssl version` alla riga di comando per vedere se OpenSSL è già installato. In caso contrario, puoi compilare e installare il codice sorgente seguendo le istruzioni disponibili nell'[ GitHub archivio pubblico](https://github.com/openssl/openssl) o utilizzare il tuo gestore di pacchetti preferito. [OpenSSL è installato anche sulle immagini Linux di Elastic Beanstalk, quindi un'alternativa rapida è connettersi a EC2 un'istanza in un ambiente in esecuzione utilizzando il comando dell'EB CLI:](eb-cli3.md) **eb ssh**
```
~/eb$ eb ssh
[ec2-user@ip-255-55-55-255 ~]$ openssl version
OpenSSL 1.0.1k-fips 8 Jan 2015
```
È necessario creare una chiave privata RSA per creare la richiesta di firma del certificato (CSR). Per creare la chiave privata, utilizza il comando **openssl genrsa**:
```
[ec2-user@ip-255-55-55-255 ~]$ openssl genrsa 2048 > privatekey.pem
Generating RSA private key, 2048 bit long modulus
.................................................................................................................................+++
...............+++
e is 65537 (0x10001)
```
*privatekey.pem*
Il nome del file in cui desideri salvare la chiave privata. Di solito, il comando **openssl genrsa** stampa il contenuto della chiave privata sullo schermo, ma questo memorizza l'output in un file. Scegli un nome di file e memorizza il file in uno spazio sicuro, in modo che sia possibile recuperarlo in un secondo momento. Se perdi la chiave privata, non potrai più utilizzare il tuo certificato.
Un CSR è un file inviato a un'autorità di certificazione (CA) per richiedere un certificato server digitale. Per creare un CSR, utilizza il comando **openssl req**:
```
$ openssl req -new -key privatekey.pem -out csr.pem
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
```
Inserisci le informazioni richieste e premi **Enter (Invio)**. La tabella seguente descrive e mostra esempi per ogni campo:
****
| Nome | Descrizione | Esempio |
| --- | --- | --- |
| Nome paese | L'abbreviazione ISO di due lettere per il tuo paese. | US = Stati Uniti |
| Lo stato o la provincia | Il nome dello stato o della provincia in cui si trova la tua organizzazione. Questo nome non può essere abbreviato. | Washington |
| Locality Name (Nome località) | Il nome della città in cui si trova la tua organizzazione. | Seattle |
| Nome organizzazione | La denominazione legale completa della tua organizzazione. Non abbreviare il nome dell'organizzazione. | Example Corporation |
| Unità organizzativa | Facoltativo, per informazioni aggiuntive sull'organizzazione. | Marketing |
| Common Name (Nome comune) | Il nome di dominio completo del tuo sito Web. Deve corrispondere al nome di dominio che gli utenti vedono quando visitano il sito, in caso contrario verranno mostrati gli errori di certificato. | www.example.com |
| Indirizzo e-mail | L'indirizzo e-mail dell'amministratore del sito. | someone@example.com |
È possibile inviare la richiesta di firma a una terza parte per la firma o firmare personalmente per lo sviluppo e il test. I certificati autofirmati possono essere utilizzati anche per il backend HTTPS tra un sistema di bilanciamento del carico e le istanze. EC2
Per firmare il certificato, utilizza il comando **openssl x509**. L'esempio seguente utilizza la chiave privata del passaggio precedente (*privatekey.pem*) e la richiesta di firma (*csr.pem*) per creare un certificato pubblico denominato valido per *public.crt* giorni. *365*
```
$ openssl x509 -req -days 365 -in csr.pem -signkey privatekey.pem -out public.crt
Signature ok
subject=/C=us/ST=washington/L=seattle/O=example corporation/OU=marketing/CN=www.example.com/emailAddress=someone@example.com
Getting Private key
```
Mantieni la chiave privata e il certificato pubblico per un utilizzo successivo. Puoi annullare la richiesta di firma. [Archivia sempre la chiave privata in un percorso sicuro](https-storingprivatekeys.md) ed evita di aggiungerla al tuo codice sorgente.
Per utilizzare il certificato con la piattaforma Windows Server, è necessario convertirlo in formato PFX. Utilizza il comando seguente per creare un certificato PFX dai file della chiave privata e del certificato pubblico:
```
$ openssl pkcs12 -export -out example.com.pfx -inkey privatekey.pem -in public.crt
Enter Export Password: password
Verifying - Enter Export Password: password
```
Ora che hai un certificato, puoi [caricarlo in IAM](configuring-https-ssl-upload.md) per utilizzarlo con un sistema di bilanciamento del carico oppure [configurare le istanze nel tuo ambiente per terminare HTTPS](https-singleinstance.md).
# Caricamento di un certificato in IAM
Per utilizzare il certificato con il sistema di bilanciamento del carico dell'ambiente Elastic Beanstalk, carica il certificato e la chiave privata su (IAM). AWS Identity and Access Management Puoi utilizzare un certificato archiviato in IAM con i sistemi di bilanciamento del carico Elastic Load Balancing e le distribuzioni Amazon. CloudFront
**Nota**
AWS Certificate Manager (ACM) è lo strumento preferito per fornire, gestire e distribuire i certificati del server. Per ulteriori informazioni sulla richiesta di un certificato ACM, consulta [Richiesta di un certificato](https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request.html) nella *Guida per l'utente di AWS Certificate Manager *. Per ulteriori informazioni sull'importazione di certificati di terza parte in ACM, consulta [Importazione di certificati](https://docs.aws.amazon.com/acm/latest/userguide/import-certificate.html) nella *Guida per l'utente di AWS Certificate Manager *. Utilizza IAM per caricare un certificato solo se ACM non è [disponibile nella](https://docs.aws.amazon.com/general/latest/gr/acm.html) tua regione. AWS
Puoi usare AWS Command Line Interface (AWS CLI) per caricare il tuo certificato. Il comando seguente carica un certificato autofirmato denominato *https-cert.crt* con una chiave privata denominata: *private-key.pem*
```
$ aws iam upload-server-certificate --server-certificate-name elastic-beanstalk-x509 --certificate-body file://https-cert.crt --private-key file://private-key.pem
{
"ServerCertificateMetadata": {
"ServerCertificateId": "AS5YBEIONO2Q7CAIHKNGC",
"ServerCertificateName": "elastic-beanstalk-x509",
"Expiration": "2017-01-31T23:06:22Z",
"Path": "/",
"Arn": "arn:aws:iam::123456789012:server-certificate/elastic-beanstalk-x509",
"UploadDate": "2016-02-01T23:10:34.167Z"
}
}
```
Il `file://` prefisso indica AWS CLI a di caricare il contenuto di un file nella directory corrente. *elastic-beanstalk-x509*specifica il nome per chiamare il certificato in IAM.
Se hai acquistato un certificato da un'autorità di certificazione e hai ricevuto un file della catena di certificati, carica anche questo file includendo l'opzione `--certificate-chain`:
```
$ aws iam upload-server-certificate --server-certificate-name elastic-beanstalk-x509 --certificate-chain file://certificate-chain.pem --certificate-body file://https-cert.crt --private-key file://private-key.pem
```
Annota l'Amazon Resource Name (ARN) per il certificato. Lo userai quando aggiorni le impostazioni di configurazione del sistema di bilanciamento del carico per l'uso di HTTPS.
**Nota**
Un certificato caricato in IAM rimane archiviato anche quando non è più in uso in alcun sistema di bilanciamento del carico dell'ambiente. Il certificato contiene dati sensibili. Quando non è più necessario per nessun ambiente, assicurati di eliminarlo. Per informazioni dettagliate sull'eliminazione di un certificato da IAM, consulta [https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html#delete-server-certificate](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html#delete-server-certificate).
Per ulteriori informazioni sui certificati server in IAM, consulta l'argomento relativo all'[utilizzo dei certificati server](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html) nella *Guida per l'utente di IAM*.
# Archiviazione di chiavi private in modo sicuro in Amazon S3
La chiave privata che usi per firmare i certificati pubblici è privata e non deve esserne eseguito il commit nel codice sorgente. Puoi evitare di archiviare le chiavi private nei file di configurazione caricandoli in Amazon S3 e configurando Elastic Beanstalk in modo che scarichi il file da Amazon S3 durante la distribuzione dell'applicazione.
L'esempio seguente mostra le sezioni [Resources](environment-resources.md) e [files](customize-containers-ec2.md#linux-files) di un [file di configurazione](ebextensions.md) che scarica un file di chiavi private da un bucket Amazon S3.
**Example .ebextensions/privatekey.config**
```
Resources:
AWSEBAutoScalingGroup:
Metadata:
AWS::CloudFormation::Authentication:
S3Auth:
type: "s3"
buckets: ["elasticbeanstalk-us-west-2-123456789012"]
roleName:
"Fn::GetOptionSetting":
Namespace: "aws:autoscaling:launchconfiguration"
OptionName: "IamInstanceProfile"
DefaultValue: "aws-elasticbeanstalk-ec2-role"
files:
# Private key
"/etc/pki/tls/certs/server.key":
mode: "000400"
owner: root
group: root
authentication: "S3Auth"
source: https://elasticbeanstalk-us-west-2-123456789012.s3.us-west-2.amazonaws.com/server.key
```
Sostituisci il nome del bucket e l'URL dell'esempio con quelli personalizzati. La prima voce di questo file aggiunge un metodo di autenticazione denominato `S3Auth` ai metadati del gruppo Auto Scaling dell'ambiente. Se hai configurato un [profilo di istanza](concepts-roles-instance.md) personalizzato per il tuo ambiente, verrà utilizzato. In caso contrario, viene applicato il valore predefinito `aws-elasticbeanstalk-ec2-role`. Il profilo di istanza predefinito è dotato dell'autorizzazione di leggere dal bucket di storage di Elastic Beanstalk. Se utilizzi un altro bucket, [aggiungi le autorizzazioni al profilo dell'istanza](iam-instanceprofile.md#iam-instanceprofile-addperms).
La seconda voce usa il metodo di autenticazione `S3Auth` per scaricare la chiave privata dall'URL specificato e salvarla `/etc/pki/tls/certs/server.key`. Il server proxy è in grado di leggere la chiave privata da questa posizione per [terminare le connessioni HTTPS presso l'istanza](https-singleinstance.md).
Il profilo dell'istanza assegnato alle EC2 istanze del tuo ambiente deve avere l'autorizzazione a leggere l'oggetto chiave dal bucket specificato. [Verifica che il profilo dell'istanza abbia l'autorizzazione](iam-instanceprofile.md#iam-instanceprofile-verify) per leggere l'oggetto in IAM e che le autorizzazioni del bucket e dell'oggetto non impediscano l'accesso al profilo dell'istanza.
**Per visualizzare le autorizzazioni di un bucket**
1. Apri la [console di gestione Amazon S3](https://console.aws.amazon.com/s3/home).
1. Scegli un bucket.
1. Scegli **Properties (Proprietà)**, quindi **Permissions (Autorizzazioni)**.
1. Verifica che il tuo account sia un assegnatario per il bucket con autorizzazione di lettura.
1. Se una policy del bucket è collegata, seleziona **Bucket policy (Policy bucket)** per visualizzare le autorizzazioni assegnate al bucket.
# Configurazione della terminazione HTTPS sul sistema di bilanciamento del carico
Per aggiornare AWS Elastic Beanstalk l'ambiente in modo da utilizzare HTTPS, è necessario configurare un listener HTTPS per il sistema di bilanciamento del carico dell'ambiente. Due tipi di sistema di bilanciamento del carico supportano un listener HTTPS: Classic Load Balancer e Application Load Balancer.
Puoi utilizzare la console Elastic Beanstalk o un file di configurazione per impostare un listener protetto a cui assegnare il certificato.
**Nota**
Gli ambienti di singola istanza non dispongono di un sistema di bilanciamento del carico e non supportano la chiusura di HTTPS nel sistema di bilanciamento del carico.
## Configurazione di un listener protetto utilizzando la console Elastic Beanstalk
**Per assegnare un certificato al sistema di bilanciamento del carico del tuo ambiente**
1. Apri la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) e, **nell'elenco Regioni, seleziona la tua**. Regione AWS
1. Nel pannello di navigazione selezionare **Environments** (Ambienti), quindi selezionare il nome dell'ambiente dall'elenco.
1. Nel riquadro di navigazione, seleziona **Configuration** (Configurazione).
1. Nella categoria di configurazione **Load balancer (Sistema di bilanciamento del carico)**, scegliere **Edit (Modifica)**.
**Nota**
Se la categoria di configurazione di **Load balancer (Sistema di bilanciamento del carico)** non presenta un pulsante **Edit (Modifica)**, il tuo ambiente non dispone di un [sistema di bilanciamento del carico](using-features-managing-env-types.md#using-features.managing.changetype).
1. Nella pagina **Modify load balancer (Modifica sistema di bilanciamento del carico)**, la procedura varia a seconda del tipo di sistema di bilanciamento del carico associato al tuo ambiente.
+ **Classic Load Balancer**
1. Scegli **Add listener (Aggiungi listener)**.
1. Nella finestra di dialogo **Classic Load Balancer listener (Listener del sistema di bilanciamento del carico)** configura le impostazioni seguenti:
+ In **Listener port (Porta listener)**, indica la porta per il traffico in entrata, generalmente `443`.
+ In **Listener protocol (Protocollo listener)**, scegli **HTTPS**.
+ In **Instance port (Porta istanza)**, digita `80`.
+ In **Instance protocol (Protocollo istanza)**, scegli **HTTP**.
+ In **SSL certificate (Certificato SSL)**, scegli il tuo certificato.
1. Scegliere **Aggiungi**.
+ **Application Load Balancer**
1. Scegli **Add listener (Aggiungi listener)**.
1. Nella finestra di dialogo **Application Load Balancer listener (Listener del sistema di bilanciamento del carico applicazioni)** configura le impostazioni seguenti:
+ In **Port (Porta)**, indica la porta per il traffico in entrata, generalmente `443`.
+ In **Protocol (Protocollo)**, scegli **HTTPS**.
+ In **SSL certificate (Certificato SSL)**, scegli il tuo certificato.
1. Scegliere **Aggiungi**.
**Nota**
Se il menu a discesa di Classic Load Balancer o Application Load Balancer non mostra alcun certificato, devi creare o caricare un [certificato per il nome di dominio personalizzato](customdomains.md) in [AWS Certificate Manager (ACM)](https://docs.aws.amazon.com/acm/latest/userguide/) (scelta consigliata). In alternativa, carica un certificato in IAM con l' AWS CLI.
+ **Network Load Balancer**
1. Scegli **Add listener (Aggiungi listener)**.
1. Nella finestra di dialogo **Network Load Balancer listener (Listener del Sistema di bilanciamento del carico di rete)** specifica la **porta** di traffico in entrata, generalmente la `443`.
1. Scegliere **Aggiungi**.
1. Per salvare le modifiche scegli **Apply** (Applica) nella parte inferiore della pagina.
## Configurazione di un listener protetto utilizzando un file di configurazione
Puoi configurare un listener sicuro sul tuo sistema di bilanciamento del carico utilizzando uno dei seguenti [file di configurazione](ebextensions.md).
**Example .ebextensions/securelistener-clb.config**
Utilizza questo esempio quando l'ambiente dispone di un sistema Classic Load Balancer. L'esempio usa le opzioni dello spazio dei nomi `aws:elb:listener` per configurare un listener HTTPS sulla porta 443 con il certificato specificato e inoltrare il traffico decrittografato alle istanze nel tuo ambiente sulla porta 80.
```
option_settings:
aws:elb:listener:443:
SSLCertificateId: arn:aws:acm:us-east-2:1234567890123:certificate/####################################
ListenerProtocol: HTTPS
InstancePort: 80
```
Sostituisci il testo evidenziato con l'ARN del tuo certificato. Il certificato può essere uno che hai creato o caricato in AWS Certificate Manager (ACM) (preferito) o uno che hai caricato su IAM con. AWS CLI
Per ulteriori informazioni sulle opzioni di configurazione di Classic Load Balancer, consulta [Spazi dei nomi di configurazione di Classic Load Balancer](environments-cfg-clb.md#environments-cfg-clb-namespace).
**Example .ebextensions/securelistener-alb.config**
Utilizza questo esempio quando l'ambiente dispone di un sistema Application Load Balancer. L'esempio utilizza le opzioni dello spazio dei nomi `aws:elbv2:listener` per configurare un listener HTTPS sulla porta 443 con il certificato specificato. Il listener instrada il traffico verso il processo predefinito.
```
option_settings:
aws:elbv2:listener:443:
ListenerEnabled: 'true'
Protocol: HTTPS
SSLCertificateArns: arn:aws:acm:us-east-2:1234567890123:certificate/####################################
```
**Example .ebextensions/securelistener-nlb.config**
Utilizza questo esempio quando l'ambiente dispone di un sistema Network Load Balancer. L'esempio utilizza le opzioni nel namespace `aws:elbv2:listener` per configurare un listener sulla porta 443. Il listener instrada il traffico verso il processo predefinito.
```
option_settings:
aws:elbv2:listener:443:
ListenerEnabled: 'true'
```
## Configurazione di un gruppo di sicurezza
Se configuri il sistema di bilanciamento del carico per inoltrare il traffico verso una porta dell'istanza diversa dalla porta 80, devi aggiungere una regola al gruppo di sicurezza che consente il traffico in entrata sulla porta dell'istanza dal sistema di bilanciamento del carico. Se crei il tuo ambiente in un VPC personalizzato, questa regola viene aggiunta automaticamente da Elastic Beanstalk.
Puoi aggiungere la regola inserendo una chiave `Resources` a un [file di configurazione](ebextensions.md) nella directory `.ebextensions` per la tua applicazione.
Il seguente file di configurazione di esempio aggiunge una regola in ingresso per il gruppo di sicurezza `AWSEBSecurityGroup`. Ciò consente il traffico sulla porta 1000 dal gruppo di sicurezza del sistema di bilanciamento del carico.
**Example .ebextensions/sg-ingressfromlb.config**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 1000
FromPort: 1000
SourceSecurityGroupId: {"Fn::GetAtt" : ["AWSEBLoadBalancerSecurityGroup", "GroupId"]}
```
# Configurazione della terminazione HTTPS sull'istanza
Puoi utilizzare i [file di configurazione](ebextensions.md) per configurare il server proxy che trasferisce il traffico verso la tua applicazione in modo da terminare le connessioni HTTPS. Questa funzione è utile se desideri utilizzare HTTPS con un ambiente di istanza singola oppure se configuri il sistema di bilanciamento del carico per inoltrare il traffico senza decrittografarlo.
Per abilitare HTTPS, devi consentire il traffico in entrata sulla porta 443 verso l' EC2 istanza su cui è in esecuzione l'applicazione Elastic Beanstalk. A tale scopo, utilizza la `Resources` chiave nel file di configurazione per aggiungere una regola per la porta 443 alle regole di ingresso per il gruppo di sicurezza del gruppo. AWSEBSecurity
Il seguente frammento aggiunge una regola di ingresso al gruppo di sicurezza `AWSEBSecurityGroup` che apre la porta 443 a tutto il traffico per un ambiente di istanza singola:
**`.ebextensions/https-instance-securitygroup.config`**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
In un ambiente con bilanciamento del carico con un [Amazon Virtual Private Cloud](https://docs.aws.amazon.com/vpc/latest/userguide/) (Amazon VPC) predefinito, puoi modificare questa policy per accettare solo il traffico proveniente dal sistema di bilanciamento del carico. Consulta [Configurazione della end-to-end crittografia in un ambiente Elastic Beanstalk con carico bilanciato](configuring-https-endtoend.md) per un esempio.
**Topics**
+ [
# Terminazione di HTTPS su istanze EC2 in cui è in esecuzione Docker
](https-singleinstance-docker.md)
+ [
# Terminazione di HTTPS sulle EC2 istanze che eseguono Go
](https-singleinstance-go.md)
+ [
# Terminazione di HTTPS su istanze EC2 che eseguono Java SE
](https-singleinstance-java.md)
+ [
# Terminazione di HTTPS nelle istanze EC2 che eseguono Node.js
](https-singleinstance-nodejs.md)
+ [
# Terminazione di HTTPS su EC2 istanze che eseguono PHP
](https-singleinstance-php.md)
+ [
# Terminazione di HTTPS su istanze EC2 che eseguono Python
](https-singleinstance-python.md)
+ [
# Terminazione di HTTPS su istanze EC2 che eseguono Ruby
](https-singleinstance-ruby.md)
+ [
# Terminazione di HTTPS su istanze EC2 che eseguono Tomcat
](https-singleinstance-tomcat.md)
+ [
# Terminazione di HTTPS su istanze Amazon EC2 che eseguono .NET Core su Linux
](https-singleinstance-dotnet-linux.md)
+ [
# Terminazione di HTTPS su EC2 istanze Amazon che eseguono.NET
](SSLNET.SingleInstance.md)
# Terminazione di HTTPS su istanze EC2 in cui è in esecuzione Docker
Per i container Docker, è possibile utilizzare un [file di configurazione](ebextensions.md) per abilitare HTTPS.
Aggiungi il frammento di codice seguente al file di configurazione, sostituendo il materiale del certificato e della chiave privata come indicato, quindi salvalo nella directory `.ebextensions` del bundle di origine. Il file di configurazione esegue le seguenti attività:
+ La chiave `files` crea i seguenti file sull'istanza:
`/etc/nginx/conf.d/https.conf`
Configura il server nginx. Questo file viene caricato quando si avvia il servizio nginx.
`/etc/pki/tls/certs/server.crt`
Crea il file di certificato sull'istanza. Sostituiscilo *certificate file contents* con il contenuto del certificato.
YAML si basa sulla coerenza del rientro. Utilizza lo stesso livello di rientro quando sostituisci del contenuto in un file di configurazione di esempio e assicurati che il tuo editor di testo utilizzi gli spazi e non le tabulazioni per il rientro.
Se disponi di certificati intermedi, includili in `server.crt` dopo il certificato del sito.
```
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
first intermediate certificate
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
second intermediate certificate
-----END CERTIFICATE-----
```
`/etc/pki/tls/certs/server.key`
Crea il file della chiave privata sull'istanza. Sostituisci *private key contents* con il contenuto della chiave privata utilizzata per creare la richiesta di certificato o il certificato autofirmato.
**Example .ebextensions/https-instance.config**
```
files:
/etc/nginx/conf.d/https.conf:
mode: "000644"
owner: root
group: root
content: |
# HTTPS Server
server {
listen 443;
server_name localhost;
ssl on;
ssl_certificate /etc/pki/tls/certs/server.crt;
ssl_certificate_key /etc/pki/tls/certs/server.key;
ssl_session_timeout 5m;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_prefer_server_ciphers on;
location / {
proxy_pass http://docker;
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto https;
}
}
/etc/pki/tls/certs/server.crt:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
/etc/pki/tls/certs/server.key:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN RSA PRIVATE KEY-----
private key contents # See note below.
-----END RSA PRIVATE KEY-----
```
**Nota**
Non utilizzare un file di configurazione che contiene la tua chiave per il controllo delle origini. Una volta eseguito il test e verificato che la configurazione funzioni, archivia la tua chiave privata in Amazon S3 e modifica la configurazione per scaricarla durante la distribuzione. Per istruzioni, consulta [Archiviazione di chiavi private in modo sicuro in Amazon S3](https-storingprivatekeys.md).
In un ambiente con una singola istanza, devi anche modificare il gruppo di sicurezza dell'istanza per consentire il traffico sulla porta 443. Il seguente file di configurazione recupera l'ID del gruppo di sicurezza utilizzando una CloudFormation [funzione](ebextensions-functions.md) e vi aggiunge una regola.
**Example .ebextensions/ https-instance-single .config**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
[Per un ambiente con bilanciamento del carico, è possibile configurare il sistema di bilanciamento del carico in modo da far [passare il traffico sicuro](https-tcp-passthrough.md) in modo inalterato oppure decriptarlo e ricrittografarlo per la crittografia.](configuring-https-endtoend.md) end-to-end
# Terminazione di HTTPS sulle EC2 istanze che eseguono Go
Per i tipi di container Go, devi attivare HTTPS con un [file di configurazione](ebextensions.md) e un file di configurazione nginx che configura il server nginx per l'utilizzo di HTTPS.
Aggiungi il seguente frammento al file di configurazione, sostituendo il certificato e il materiale della chiave privata come indicato, e salvalo nella directory `.ebextensions` del bundle di origine. Il file di configurazione esegue le seguenti attività:
+ La chiave `Resources` attiva la porta 443 sul gruppo di sicurezza utilizzato dall'istanza dell'ambiente.
+ La chiave `files` crea i seguenti file sull'istanza:
`/etc/pki/tls/certs/server.crt`
Crea il file di certificato sull'istanza. *certificate file contents*Sostituiscilo con il contenuto del tuo certificato.
YAML si basa sulla coerenza del rientro. Utilizza lo stesso livello di rientro quando sostituisci del contenuto in un file di configurazione di esempio e assicurati che il tuo editor di testo utilizzi gli spazi e non le tabulazioni per il rientro.
Se disponi di certificati intermedi, includili in `server.crt` dopo il certificato del sito.
```
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
first intermediate certificate
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
second intermediate certificate
-----END CERTIFICATE-----
```
`/etc/pki/tls/certs/server.key`
Crea il file della chiave privata sull'istanza. Sostituisci *private key contents* con il contenuto della chiave privata utilizzata per creare la richiesta di certificato o il certificato autofirmato.
**Example .ebextensions/https-instance.config**
```
files:
/etc/pki/tls/certs/server.crt:
content: |
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
/etc/pki/tls/certs/server.key:
content: |
-----BEGIN RSA PRIVATE KEY-----
private key contents # See note below.
-----END RSA PRIVATE KEY-----
```
**Nota**
Non utilizzare un file di configurazione che contiene la tua chiave per il controllo delle origini. Una volta eseguito il test e verificato che la configurazione funzioni, archivia la tua chiave privata in Amazon S3 e modifica la configurazione per scaricarla durante la distribuzione. Per istruzioni, consulta [Archiviazione di chiavi private in modo sicuro in Amazon S3](https-storingprivatekeys.md).
Inserisci quanto segue in un file con estensione `.conf` nella directory `.ebextensions/nginx/conf.d/` del bundle di origine (ad esempio, `.ebextensions/nginx/conf.d/https.conf`). *app\$1port*Sostituiscilo con il numero di porta su cui l'applicazione è in ascolto. Questo esempio configura il server nginx per l'ascolto sulla porta 443 tramite SSL. Per ulteriori informazioni su questi file di configurazione sulla piattaforma Go, consulta [Configurazione del server proxy](go-nginx.md).
**Example . ebextensions/nginx/conf.d/https.conf**
```
# HTTPS server
server {
listen 443;
server_name localhost;
ssl on;
ssl_certificate /etc/pki/tls/certs/server.crt;
ssl_certificate_key /etc/pki/tls/certs/server.key;
ssl_session_timeout 5m;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_prefer_server_ciphers on;
location / {
proxy_pass http://localhost:app_port;
proxy_set_header Connection "";
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto https;
}
}
```
In un ambiente con una singola istanza, devi anche modificare il gruppo di sicurezza dell'istanza per consentire il traffico sulla porta 443. Il seguente file di configurazione recupera l'ID del gruppo di sicurezza utilizzando una CloudFormation [funzione](ebextensions-functions.md) e vi aggiunge una regola.
**Example .ebextensions/ https-instance-single .config**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
[Per un ambiente con bilanciamento del carico, è possibile configurare il sistema di bilanciamento del carico in modo da far [passare il traffico sicuro](https-tcp-passthrough.md) in modo inalterato oppure decriptarlo e ricrittografarlo per la crittografia.](configuring-https-endtoend.md) end-to-end
# Terminazione di HTTPS su istanze EC2 che eseguono Java SE
Per i tipi di container Java SE, devi attivare HTTPS con un [file di configurazione](ebextensions.md) .ebextensions e un file di configurazione nginx che configura il server nginx per l'utilizzo di HTTPS.
Tutte le AL2 piattaforme AL2023/supportano una funzionalità di configurazione proxy uniforme. Per ulteriori informazioni sulla configurazione del server proxy sulle versioni della piattaforma che eseguono AL2023/AL2, consulta[Configurazione del proxy inverso](platforms-linux-extend.proxy.md).
Aggiungi il seguente frammento al file di configurazione, sostituendo i segnaposti di certificato e chiave privata come indicato, e salvalo nella directory `.ebextensions`. Il file di configurazione esegue le seguenti attività:
+ La chiave `files` crea i seguenti file sull'istanza:
`/etc/pki/tls/certs/server.crt`
Crea il file di certificato sull'istanza. Sostituiscilo *certificate file contents* con il contenuto del certificato.
YAML si basa sulla coerenza del rientro. Utilizza lo stesso livello di rientro quando sostituisci del contenuto in un file di configurazione di esempio e assicurati che il tuo editor di testo utilizzi gli spazi e non le tabulazioni per il rientro.
Se disponi di certificati intermedi, includili in `server.crt` dopo il certificato del sito.
```
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
first intermediate certificate
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
second intermediate certificate
-----END CERTIFICATE-----
```
`/etc/pki/tls/certs/server.key`
Crea il file della chiave privata sull'istanza. Sostituisci *private key contents* con il contenuto della chiave privata utilizzata per creare la richiesta di certificato o il certificato autofirmato.
**Example .ebextensions/https-instance.config**
```
files:
/etc/pki/tls/certs/server.crt:
content: |
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
/etc/pki/tls/certs/server.key:
content: |
-----BEGIN RSA PRIVATE KEY-----
private key contents # See note below.
-----END RSA PRIVATE KEY-----
```
**Nota**
Non utilizzare un file di configurazione che contiene la tua chiave per il controllo delle origini. Una volta eseguito il test e verificato che la configurazione funzioni, archivia la tua chiave privata in Amazon S3 e modifica la configurazione per scaricarla durante la distribuzione. Per istruzioni, consulta [Archiviazione di chiavi private in modo sicuro in Amazon S3](https-storingprivatekeys.md).
Inserisci quanto segue in un file con estensione `.conf` nella directory `.ebextensions/nginx/conf.d/` del bundle di origine (ad esempio, `.ebextensions/nginx/conf.d/https.conf`). *app\$1port*Sostituiscilo con il numero di porta su cui l'applicazione è in ascolto. Questo esempio configura il server nginx per l'ascolto sulla porta 443 tramite SSL. Per ulteriori informazioni su questi file di configurazione sulla piattaforma Java SE, consulta [Configurazione del server proxy](java-se-nginx.md).
**Example . ebextensions/nginx/conf.d/https.conf**
```
# HTTPS server
server {
listen 443;
server_name localhost;
ssl on;
ssl_certificate /etc/pki/tls/certs/server.crt;
ssl_certificate_key /etc/pki/tls/certs/server.key;
ssl_session_timeout 5m;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_prefer_server_ciphers on;
location / {
proxy_pass http://localhost:app_port;
proxy_set_header Connection "";
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto https;
}
}
```
In un ambiente con una singola istanza, devi anche modificare il gruppo di sicurezza dell'istanza per consentire il traffico sulla porta 443. Il seguente file di configurazione recupera l'ID del gruppo di sicurezza utilizzando una CloudFormation [funzione](ebextensions-functions.md) e vi aggiunge una regola.
**Example .ebextensions/ https-instance-single .config**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
[Per un ambiente con bilanciamento del carico, è possibile configurare il sistema di bilanciamento del carico in modo da far [passare il traffico sicuro](https-tcp-passthrough.md) in modo inalterato oppure decriptarlo e ricrittografarlo per la crittografia.](configuring-https-endtoend.md) end-to-end
# Terminazione di HTTPS nelle istanze EC2 che eseguono Node.js
Il seguente file di configurazione di esempio [estende la configurazione nginx predefinita](nodejs-platform-proxy.md) per ascoltare sulla porta 443 e SSL/TLS terminare le connessioni con un certificato pubblico e una chiave privata.
Se hai configurato l'ambiente per il [reporting sullo stato migliorato](health-enhanced.md), è necessario configurare nginx per generare i log di accesso. A tale scopo, rimuovi i commenti dal blocco di linee sotto il commento la cui dicitura è `# For enhanced health...` rimuovendo i caratteri iniziali `#`.
**Example .ebextensions/https-instance.config**
```
files:
/etc/nginx/conf.d/https.conf:
mode: "000644"
owner: root
group: root
content: |
# HTTPS server
server {
listen 443;
server_name localhost;
ssl on;
ssl_certificate /etc/pki/tls/certs/server.crt;
ssl_certificate_key /etc/pki/tls/certs/server.key;
ssl_session_timeout 5m;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_prefer_server_ciphers on;
# For enhanced health reporting support, uncomment this block:
#if ($time_iso8601 ~ "^(\d{4})-(\d{2})-(\d{2})T(\d{2})") {
# set $year $1;
# set $month $2;
# set $day $3;
# set $hour $4;
#}
#access_log /var/log/nginx/healthd/application.log.$year-$month-$day-$hour healthd;
#access_log /var/log/nginx/access.log main;
location / {
proxy_pass http://nodejs;
proxy_set_header Connection "";
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto https;
}
}
/etc/pki/tls/certs/server.crt:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
/etc/pki/tls/certs/server.key:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN RSA PRIVATE KEY-----
private key contents # See note below.
-----END RSA PRIVATE KEY-----
```
La chiave `files` crea i seguenti file sull'istanza:
`/etc/nginx/conf.d/https.conf`
Configura il server nginx. Questo file viene caricato quando si avvia il servizio nginx.
`/etc/pki/tls/certs/server.crt`
Crea il file di certificato sull'istanza. Sostituiscilo *certificate file contents* con il contenuto del tuo certificato.
YAML si basa sulla coerenza del rientro. Utilizza lo stesso livello di rientro quando sostituisci del contenuto in un file di configurazione di esempio e assicurati che il tuo editor di testo utilizzi gli spazi e non le tabulazioni per il rientro.
Se disponi di certificati intermedi, includili in `server.crt` dopo il certificato del sito.
```
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
first intermediate certificate
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
second intermediate certificate
-----END CERTIFICATE-----
```
`/etc/pki/tls/certs/server.key`
Crea il file della chiave privata sull'istanza. Sostituiscilo *private key contents* con il contenuto della chiave privata utilizzata per creare la richiesta di certificato o il certificato autofirmato.
**Nota**
Non utilizzare un file di configurazione che contiene la tua chiave per il controllo delle origini. Una volta eseguito il test e verificato che la configurazione funzioni, archivia la tua chiave privata in Amazon S3 e modifica la configurazione per scaricarla durante la distribuzione. Per istruzioni, consulta [Archiviazione di chiavi private in modo sicuro in Amazon S3](https-storingprivatekeys.md).
In un ambiente con una singola istanza, devi anche modificare il gruppo di sicurezza dell'istanza per consentire il traffico sulla porta 443. Il seguente file di configurazione recupera l'ID del gruppo di sicurezza utilizzando una CloudFormation [funzione](ebextensions-functions.md) e vi aggiunge una regola.
**Example .ebextensions/ https-instance-single .config**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
[Per un ambiente con bilanciamento del carico, è possibile configurare il sistema di bilanciamento del carico in modo da far [passare il traffico sicuro](https-tcp-passthrough.md) in modo inalterato oppure decriptarlo e ricrittografarlo per la crittografia.](configuring-https-endtoend.md) end-to-end
# Terminazione di HTTPS su EC2 istanze che eseguono PHP
Per i tipi di container PHP, devi usare un [file di configurazione](ebextensions.md) per abilitare Apache HTTP Server per l'utilizzo di HTTPS.
Aggiungi il frammento di codice seguente al file di configurazione, sostituendo il materiale del certificato e della chiave privata come indicato, quindi salvalo nella directory `.ebextensions` del bundle di origine.
Il file di configurazione esegue le seguenti attività:
+ La chiave `packages` utilizza yum per installare `mod24_ssl`.
+ La chiave `files` crea i seguenti file sull'istanza:
`/etc/httpd/conf.d/ssl.conf`
Configura il server Apache. Questo file viene caricato all'avvio del servizio Apache.
`/etc/pki/tls/certs/server.crt`
Crea il file di certificato sull'istanza. *certificate file contents*Sostituiscilo con il contenuto del tuo certificato.
YAML si basa sulla coerenza del rientro. Utilizza lo stesso livello di rientro quando sostituisci del contenuto in un file di configurazione di esempio e assicurati che il tuo editor di testo utilizzi gli spazi e non le tabulazioni per il rientro.
Se disponi di certificati intermedi, includili in `server.crt` dopo il certificato del sito.
```
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
first intermediate certificate
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
second intermediate certificate
-----END CERTIFICATE-----
```
`/etc/pki/tls/certs/server.key`
Crea il file della chiave privata sull'istanza. Sostituisci *private key contents* con il contenuto della chiave privata utilizzata per creare la richiesta di certificato o il certificato autofirmato.
**Example .ebextensions/https-instance.config**
```
packages:
yum:
mod24_ssl : []
files:
/etc/httpd/conf.d/ssl.conf:
mode: "000644"
owner: root
group: root
content: |
LoadModule ssl_module modules/mod_ssl.so
Listen 443
Order deny,allow
Allow from all
SSLEngine on
SSLCertificateFile "/etc/pki/tls/certs/server.crt"
SSLCertificateKeyFile "/etc/pki/tls/certs/server.key"
SSLCipherSuite EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH
SSLProtocol All -SSLv2 -SSLv3
SSLHonorCipherOrder On
SSLSessionTickets Off
Header always set Strict-Transport-Security "max-age=63072000; includeSubdomains; preload"
Header always set X-Frame-Options DENY
Header always set X-Content-Type-Options nosniff
ProxyPass / http://localhost:80/ retry=0
ProxyPassReverse / http://localhost:80/
ProxyPreserveHost on
RequestHeader set X-Forwarded-Proto "https" early
/etc/pki/tls/certs/server.crt:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
/etc/pki/tls/certs/server.key:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN RSA PRIVATE KEY-----
private key contents # See note below.
-----END RSA PRIVATE KEY-----
```
**Nota**
Non utilizzare un file di configurazione che contiene la tua chiave per il controllo delle origini. Una volta eseguito il test e verificato che la configurazione funzioni, archivia la tua chiave privata in Amazon S3 e modifica la configurazione per scaricarla durante la distribuzione. Per istruzioni, consulta [Archiviazione di chiavi private in modo sicuro in Amazon S3](https-storingprivatekeys.md).
In un ambiente con una singola istanza, devi anche modificare il gruppo di sicurezza dell'istanza per consentire il traffico sulla porta 443. Il seguente file di configurazione recupera l'ID del gruppo di sicurezza utilizzando una CloudFormation [funzione](ebextensions-functions.md) e vi aggiunge una regola.
**Example .ebextensions/ https-instance-single .config**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
[Per un ambiente con bilanciamento del carico, è possibile configurare il sistema di bilanciamento del carico in modo da far [passare il traffico sicuro](https-tcp-passthrough.md) in modo inalterato oppure decriptarlo e ricrittografarlo per la crittografia.](configuring-https-endtoend.md) end-to-end
# Terminazione di HTTPS su istanze EC2 che eseguono Python
Per i tipi di container Python che utilizzano Apache HTTP Server con l'interfaccia WSGI (Web Server Gateway Interface), devi utilizzare un [file di configurazione](ebextensions.md) per consentire ad Apache HTTP Server di utilizzare HTTPS.
Aggiungi il seguente frammento al [file di configurazione](ebextensions.md), sostituendo i segnaposto di certificato e chiave privata come indicato, quindi salvalo nella directory `.ebextensions` del bundle di origine. Il file di configurazione esegue le seguenti attività:
+ La chiave `packages` utilizza yum per installare `mod_ssl`.
+ La chiave `files` crea i seguenti file sull'istanza:
`/etc/httpd/conf.d/ssl.conf`
Configura il server Apache. Se la tua applicazione non è denominata `application.py`, sostituisci il testo evidenziato nel valore per `WSGIScriptAlias` con il percorso locale alla tua applicazione. Ad esempio, un'applicazione django può essere in `django/wsgi.py`. La posizione deve corrispondere al valore dell'opzione `WSGIPath` impostata per il tuo ambiente.
A seconda dei requisiti dell'applicazione, potrebbe essere necessario aggiungere anche altre directory al parametro **python-path**.
`/etc/pki/tls/certs/server.crt`
Crea il file di certificato sull'istanza. Sostituiscilo *certificate file contents* con il contenuto del certificato.
YAML si basa sulla coerenza del rientro. Utilizza lo stesso livello di rientro quando sostituisci del contenuto in un file di configurazione di esempio e assicurati che il tuo editor di testo utilizzi gli spazi e non le tabulazioni per il rientro.
Se disponi di certificati intermedi, includili in `server.crt` dopo il certificato del sito.
```
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
first intermediate certificate
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
second intermediate certificate
-----END CERTIFICATE-----
```
`/etc/pki/tls/certs/server.key`
Crea il file della chiave privata sull'istanza. Sostituiscilo *private key contents* con il contenuto della chiave privata utilizzata per creare la richiesta di certificato o il certificato autofirmato.
+ La chiave `container_commands` interrompe il servizio httpd dopo che tutto è stato configurato in modo che il servizio utilizzi il nuovo certificato e il nuovo file `https.conf`.
**Nota**
L'esempio funziona solo in ambienti che utilizzano la piattaforma [Python](create-deploy-python-container.md).
**Example .ebextensions/https-instance.config**
```
packages:
yum:
mod_ssl: []
files:
/etc/httpd/conf.d/ssl.conf:
mode: "000644"
owner: root
group: root
content: |
LoadModule wsgi_module modules/mod_wsgi.so
WSGIPythonHome /var/app/venv/staging-LQM1lest
WSGISocketPrefix run/wsgi
WSGIRestrictEmbedded On
Listen 443
SSLEngine on
SSLCertificateFile "/etc/pki/tls/certs/server.crt"
SSLCertificateKeyFile "/etc/pki/tls/certs/server.key"
Alias /static/ /var/app/current/static/
Order allow,deny
Allow from all
WSGIScriptAlias / /var/app/current/application.py
Require all granted
WSGIDaemonProcess wsgi-ssl processes=1 threads=15 display-name=%{GROUP} \
python-path=/var/app/current \
python-home=/var/app/venv/staging-LQM1lest \
home=/var/app/current \
user=webapp \
group=webapp
WSGIProcessGroup wsgi-ssl
/etc/pki/tls/certs/server.crt:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
/etc/pki/tls/certs/server.key:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN RSA PRIVATE KEY-----
private key contents # See note below.
-----END RSA PRIVATE KEY-----
container_commands:
01killhttpd:
command: "killall httpd"
02waitforhttpddeath:
command: "sleep 3"
```
**Nota**
Non utilizzare un file di configurazione che contiene la tua chiave per il controllo delle origini. Una volta eseguito il test e verificato che la configurazione funzioni, archivia la tua chiave privata in Amazon S3 e modifica la configurazione per scaricarla durante la distribuzione. Per istruzioni, consulta [Archiviazione di chiavi private in modo sicuro in Amazon S3](https-storingprivatekeys.md).
**Nota per gli ambienti Amazon Linux 2023**
Su Amazon Linux 2023, `mod_wsgi` deve essere installato separatamente in quanto non è disponibile negli archivi dei pacchetti. Per le istruzioni di installazione, vedi [mod\$1wsgi su PyPI](https://pypi.org/project/mod-wsgi/).
In un ambiente con una singola istanza, devi anche modificare il gruppo di sicurezza dell'istanza per consentire il traffico sulla porta 443. Il seguente file di configurazione recupera l'ID del gruppo di sicurezza utilizzando una CloudFormation [funzione](ebextensions-functions.md) e vi aggiunge una regola.
**Example .ebextensions/ https-instance-single .config**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
[Per un ambiente con bilanciamento del carico, è possibile configurare il sistema di bilanciamento del carico in modo da far [passare il traffico sicuro](https-tcp-passthrough.md) in modo inalterato oppure decriptarlo e ricrittografarlo per la crittografia.](configuring-https-endtoend.md) end-to-end
# Terminazione di HTTPS su istanze EC2 che eseguono Ruby
Per i tipi di container Ruby, il modo in cui abiliti HTTPS dipende dal tipo di server di applicazioni utilizzato.
**Topics**
+ [
## Configurare HTTPS per Ruby con Puma
](#Puma)
+ [
## Configurare HTTPS per Ruby con Passenger
](#Passenger)
## Configurare HTTPS per Ruby con Puma
Per i tipi di container Ruby che utilizzano Puma come server di applicazioni, utilizza un [file di configurazione](ebextensions.md) per abilitare il protocollo HTTPS.
Aggiungi il frammento di codice seguente al file di configurazione, sostituendo il materiale del certificato e della chiave privata come indicato, quindi salvalo nella directory `.ebextensions` del bundle di origine. Il file di configurazione esegue le seguenti attività:
+ La chiave `files` crea i seguenti file sull'istanza:
`/etc/nginx/conf.d/https.conf`
Configura il server nginx. Questo file viene caricato quando si avvia il servizio nginx.
`/etc/pki/tls/certs/server.crt`
Crea il file di certificato sull'istanza. Sostituiscilo *certificate file contents* con il contenuto del certificato.
YAML si basa sulla coerenza del rientro. Utilizza lo stesso livello di rientro quando sostituisci del contenuto in un file di configurazione di esempio e assicurati che il tuo editor di testo utilizzi gli spazi e non le tabulazioni per il rientro.
Se disponi di certificati intermedi, includili in `server.crt` dopo il certificato del sito.
```
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
first intermediate certificate
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
second intermediate certificate
-----END CERTIFICATE-----
```
`/etc/pki/tls/certs/server.key`
Crea il file della chiave privata sull'istanza. Sostituisci *private key contents* con il contenuto della chiave privata utilizzata per creare la richiesta di certificato o il certificato autofirmato.
**Example .ebextensions/https-instance.config**
```
files:
/etc/nginx/conf.d/https.conf:
content: |
# HTTPS server
server {
listen 443;
server_name localhost;
ssl on;
ssl_certificate /etc/pki/tls/certs/server.crt;
ssl_certificate_key /etc/pki/tls/certs/server.key;
ssl_session_timeout 5m;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_prefer_server_ciphers on;
location / {
proxy_pass http://my_app;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto https;
}
location /assets {
alias /var/app/current/public/assets;
gzip_static on;
gzip on;
expires max;
add_header Cache-Control public;
}
location /public {
alias /var/app/current/public;
gzip_static on;
gzip on;
expires max;
add_header Cache-Control public;
}
}
/etc/pki/tls/certs/server.crt:
content: |
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
/etc/pki/tls/certs/server.key:
content: |
-----BEGIN RSA PRIVATE KEY-----
private key contents # See note below.
-----END RSA PRIVATE KEY-----
```
**Nota**
Non utilizzare un file di configurazione che contiene la tua chiave per il controllo delle origini. Una volta eseguito il test e verificato che la configurazione funzioni, archivia la tua chiave privata in Amazon S3 e modifica la configurazione per scaricarla durante la distribuzione. Per istruzioni, consulta [Archiviazione di chiavi private in modo sicuro in Amazon S3](https-storingprivatekeys.md).
In un ambiente con una singola istanza, devi anche modificare il gruppo di sicurezza dell'istanza per consentire il traffico sulla porta 443. Il seguente file di configurazione recupera l'ID del gruppo di sicurezza utilizzando una CloudFormation [funzione](ebextensions-functions.md) e vi aggiunge una regola.
**Example .ebextensions/ https-instance-single .config**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
[Per un ambiente con bilanciamento del carico, è possibile configurare il sistema di bilanciamento del carico in modo da far [passare il traffico sicuro](https-tcp-passthrough.md) in modo inalterato oppure decriptarlo e ricrittografarlo per la crittografia.](configuring-https-endtoend.md) end-to-end
## Configurare HTTPS per Ruby con Passenger
Per i tipi di container Ruby che utilizzano Passenger come server di applicazioni, utilizza un file di configurazione e un file JSON per abilitare il protocollo HTTPS.
**Per configurare HTTPS per Ruby con Passenger**
1. Aggiungi il frammento di codice seguente al file di configurazione, sostituendo il materiale del certificato e della chiave privata come indicato, quindi salvalo nella directory `.ebextensions` del bundle di origine. Il file di configurazione esegue le seguenti attività:
+ La chiave `files` crea i seguenti file sull'istanza:
`/etc/pki/tls/certs/server.crt`
Crea il file di certificato sull'istanza. Sostituiscilo con il contenuto del certificato. *certificate file contents*
YAML si basa sulla coerenza del rientro. Utilizza lo stesso livello di rientro quando sostituisci del contenuto in un file di configurazione di esempio e assicurati che il tuo editor di testo utilizzi gli spazi e non le tabulazioni per il rientro.
Se disponi di certificati intermedi, includili in `server.crt` dopo il certificato del sito.
```
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
first intermediate certificate
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
second intermediate certificate
-----END CERTIFICATE-----
```
`/etc/pki/tls/certs/server.key`
Crea il file della chiave privata sull'istanza. Sostituisci *private key contents* con il contenuto della chiave privata utilizzata per creare la richiesta di certificato o il certificato autofirmato.
**Example Frammento .Ebextensions per la configurazione di HTTPS per Ruby con Passenger**
```
files:
/etc/pki/tls/certs/server.crt:
content: |
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
/etc/pki/tls/certs/server.key:
content: |
-----BEGIN RSA PRIVATE KEY-----
private key contents # See note below.
-----END RSA PRIVATE KEY-----
```
**Nota**
Non utilizzare un file di configurazione che contiene la tua chiave per il controllo delle origini. Una volta eseguito il test e verificato che la configurazione funzioni, archivia la tua chiave privata in Amazon S3 e modifica la configurazione per scaricarla durante la distribuzione. Per istruzioni, consulta [Archiviazione di chiavi private in modo sicuro in Amazon S3](https-storingprivatekeys.md).
1. Crea un file di testo e aggiungi il seguente JSON al file. Salvalo nella directory principale del bundle di origine con il nome `passenger-standalone.json`. Questo file JSON configura Passenger per l'utilizzo di HTTPS.
**Importante**
Questo file JSON non deve contenere un contrassegno ordine di byte (BOM, Byte Order Mark). In caso contrario, la libreria JSON di Passenger non leggerà il file correttamente e il servizio Passenger non verrà avviato.
**Example passenger-standalone.json**
```
{
"ssl" : true,
"ssl_port" : 443,
"ssl_certificate" : "/etc/pki/tls/certs/server.crt",
"ssl_certificate_key" : "/etc/pki/tls/certs/server.key"
}
```
In un ambiente con una singola istanza, devi anche modificare il gruppo di sicurezza dell'istanza per consentire il traffico sulla porta 443. Il seguente file di configurazione recupera l'ID del gruppo di sicurezza utilizzando una CloudFormation [funzione](ebextensions-functions.md) e vi aggiunge una regola.
**Example .ebextensions/ https-instance-single .config**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
[Per un ambiente con bilanciamento del carico, è possibile configurare il sistema di bilanciamento del carico in modo da far [passare il traffico sicuro](https-tcp-passthrough.md) in modo inalterato oppure decriptarlo e ricrittografarlo per la crittografia.](configuring-https-endtoend.md) end-to-end
# Terminazione di HTTPS su istanze EC2 che eseguono Tomcat
Per i tipi di container Tomcat, utilizza un [file di configurazione](ebextensions.md) per autorizzare Apache HTTP Server a utilizzare il protocollo HTTPS quando svolge la funzione di proxy inverso per Tomcat.
Aggiungi il frammento di codice seguente al file di configurazione, sostituendo il materiale del certificato e della chiave privata come indicato, quindi salvalo nella directory `.ebextensions` del bundle di origine. Il file di configurazione esegue le seguenti attività:
+ La chiave `files` crea i seguenti file sull'istanza:
`/etc/pki/tls/certs/server.crt`
Crea il file di certificato sull'istanza. Sostituiscilo *certificate file contents* con il contenuto del certificato.
YAML si basa sulla coerenza del rientro. Utilizza lo stesso livello di rientro quando sostituisci del contenuto in un file di configurazione di esempio e assicurati che il tuo editor di testo utilizzi gli spazi e non le tabulazioni per il rientro.
`/etc/pki/tls/certs/server.key`
Crea il file della chiave privata sull'istanza. Sostituiscilo *private key contents* con il contenuto della chiave privata utilizzata per creare la richiesta di certificato o il certificato autofirmato.
`/opt/elasticbeanstalk/hooks/appdeploy/post/99_start_httpd.sh`
Crea uno script hook post-distribuzione per riavviare il servizio httpd.
**Example .ebextensions/https-instance.config**
```
files:
/etc/pki/tls/certs/server.crt:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
/etc/pki/tls/certs/server.key:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN RSA PRIVATE KEY-----
private key contents # See note below.
-----END RSA PRIVATE KEY-----
/opt/elasticbeanstalk/hooks/appdeploy/post/99_start_httpd.sh:
mode: "000755"
owner: root
group: root
content: |
#!/usr/bin/env bash
sudo service httpd restart
```
È inoltre necessario configurare il server proxy dell'ambiente affinché ascolti la porta 443. La seguente configurazione Apache 2.4 aggiunge un listener sulla porta 443. Per ulteriori informazioni, consulta [Configurazione del server proxy](java-tomcat-proxy.md).
**Example . ebextensions/httpd/conf.d/ssl.conf**
```
Listen 443
ServerName server-name
SSLEngine on
SSLCertificateFile "/etc/pki/tls/certs/server.crt"
SSLCertificateKeyFile "/etc/pki/tls/certs/server.key"
Require all granted
ProxyPass / http://localhost:8080/ retry=0
ProxyPassReverse / http://localhost:8080/
ProxyPreserveHost on
ErrorLog /var/log/httpd/elasticbeanstalk-ssl-error_log
```
Il fornitore del certificato può includere certificati intermedi che puoi installare per migliorare la compatibilità con i client mobili. Configura Apache con il bundle di un'autorità di certificazione (CA) intermedia aggiungendo il seguente file di configurazione SSL (vedi [Estensione e sovrascrittura della configurazione predefinita di Apache — Amazon Linux AMI () AL1](java-tomcat-proxy.md#java-tomcat-proxy-apache) per la posizione):
+ Nei contenuti del file `ssl.conf` specifica il file della catena:
```
SSLCertificateKeyFile "/etc/pki/tls/certs/server.key"
SSLCertificateChainFile "/etc/pki/tls/certs/gd_bundle.crt"
SSLCipherSuite EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH
```
+ Aggiungi una nuova voce alla chiave `files` con i contenuti dei certificati intermedi:
```
files:
/etc/pki/tls/certs/gd_bundle.crt:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN CERTIFICATE-----
First intermediate certificate
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
Second intermediate certificate
-----END CERTIFICATE-----
```
**Nota**
Non utilizzare un file di configurazione che contiene la tua chiave per il controllo delle origini. Una volta eseguito il test e verificato che la configurazione funzioni, archivia la tua chiave privata in Amazon S3 e modifica la configurazione per scaricarla durante la distribuzione. Per istruzioni, consulta [Archiviazione di chiavi private in modo sicuro in Amazon S3](https-storingprivatekeys.md).
In un ambiente con una singola istanza, devi anche modificare il gruppo di sicurezza dell'istanza per consentire il traffico sulla porta 443. Il seguente file di configurazione recupera l'ID del gruppo di sicurezza utilizzando una CloudFormation [funzione](ebextensions-functions.md) e vi aggiunge una regola.
**Example .ebextensions/ https-instance-single .config**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
[Per un ambiente con bilanciamento del carico, è possibile configurare il sistema di bilanciamento del carico in modo da far [passare il traffico sicuro](https-tcp-passthrough.md) in modo inalterato oppure decriptarlo e ricrittografarlo per la crittografia.](configuring-https-endtoend.md) end-to-end
# Terminazione di HTTPS su istanze Amazon EC2 che eseguono .NET Core su Linux
Per i tipi di container .NET Core su Linux devi abilitare HTTPS con un [file di configurazione](ebextensions.md) `.ebextensions` e un file di configurazione nginx che configura il server nginx per l'utilizzo di HTTPS.
Aggiungi il seguente frammento al file di configurazione, sostituendo i segnaposti di certificato e chiave privata come indicato, e salvalo nella directory `.ebextensions`. Il file di configurazione esegue le seguenti attività:
+ La chiave `files` crea i seguenti file sull'istanza:
`/etc/pki/tls/certs/server.crt`
Crea il file di certificato sull'istanza. Sostituiscilo *certificate file contents* con il contenuto del certificato.
YAML si basa sulla coerenza del rientro. Utilizza lo stesso livello di rientro quando sostituisci del contenuto in un file di configurazione di esempio e assicurati che il tuo editor di testo utilizzi gli spazi e non le tabulazioni per il rientro.
Se disponi di certificati intermedi, includili in `server.crt` dopo il certificato del sito.
```
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
first intermediate certificate
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
second intermediate certificate
-----END CERTIFICATE-----
```
`/etc/pki/tls/certs/server.key`
Crea il file della chiave privata sull'istanza. Sostituisci *private key contents* con il contenuto della chiave privata utilizzata per creare la richiesta di certificato o il certificato autofirmato.
**Example .ebextensions/https-instance.config**
```
files:
/etc/pki/tls/certs/server.crt:
content: |
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
/etc/pki/tls/certs/server.key:
content: |
-----BEGIN RSA PRIVATE KEY-----
private key contents # See note below.
-----END RSA PRIVATE KEY-----
```
**Nota**
Non utilizzare un file di configurazione che contiene la tua chiave per il controllo delle origini. Una volta eseguito il test e verificato che la configurazione funzioni, archivia la tua chiave privata in Amazon S3 e modifica la configurazione per scaricarla durante la distribuzione. Per istruzioni, consulta [Archiviazione di chiavi private in modo sicuro in Amazon S3](https-storingprivatekeys.md).
Inserisci quanto segue in un file con estensione `.conf` nella directory `.platform/nginx/conf.d/` del bundle di origine (ad esempio, `.platform/nginx/conf.d/https.conf`). *app\$1port*Sostituiscilo con il numero di porta su cui l'applicazione è in ascolto. Questo esempio configura il server nginx per l'ascolto sulla porta 443 tramite SSL. Per ulteriori informazioni su questi file di configurazione sulla piattaforma .NET Core su Linux, consulta [Configurazione del server proxy](dotnet-linux-platform-nginx.md).
**Example . platform/nginx/conf.d/https.conf**
```
# HTTPS server
server {
listen 443 ssl;
server_name localhost;
ssl_certificate /etc/pki/tls/certs/server.crt;
ssl_certificate_key /etc/pki/tls/certs/server.key;
ssl_session_timeout 5m;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_prefer_server_ciphers on;
location / {
proxy_pass http://localhost:app_port;
proxy_set_header Connection "";
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto https;
}
}
```
In un ambiente con una singola istanza, devi anche modificare il gruppo di sicurezza dell'istanza per consentire il traffico sulla porta 443. Il seguente file di configurazione recupera l'ID del gruppo di sicurezza utilizzando una CloudFormation [funzione](ebextensions-functions.md) e vi aggiunge una regola.
**Example .ebextensions/ https-instance-single .config**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
[Per un ambiente con bilanciamento del carico, è possibile configurare il sistema di bilanciamento del carico in modo da far [passare il traffico sicuro](https-tcp-passthrough.md) in modo inalterato oppure decriptarlo e ricrittografarlo per la crittografia.](configuring-https-endtoend.md) end-to-end
# Terminazione di HTTPS su EC2 istanze Amazon che eseguono.NET
Il seguente [file di configurazione](ebextensions.md) crea ed esegue uno PowerShell script di Windows che esegue le seguenti attività:
+ Verifica la presenza di un'associazione di certificati HTTPS esistente alla porta 443.
+ Ottiene il [certificato PFX](configuring-https-ssl.md) da un bucket Amazon S3.
**Nota**
Aggiungi una `AmazonS3ReadOnlyAccess` policy per accedere `aws-elasticbeanstalk-ec2-role` al certificato SSL nel bucket Amazon S3.
+ Ottiene la password da. Gestione dei segreti AWS
**Nota**
Aggiunge un'istruzione `aws-elasticbeanstalk-ec2-role` che consenta l'`secretsmanager:GetSecretValue`azione relativa al segreto che contiene la password del certificato
+ Installa il certificato.
+ Associa il certificato alla porta 443.
**Nota**
Per rimuovere gli endpoint HTTP (porta 80), includi il comando `Remove-WebBinding` nella sezione **Rimuovi associazione HTTP** dell'esempio.
**Example .ebextensions/ .config https-instance-dotnet**
```
files:
"C:\\certs\\install-cert.ps1":
content: |
import-module webadministration
## Settings - replace the following values with your own
$bucket = "amzn-s3-demo-bucket" ## S3 bucket name
$certkey = "example.com.pfx" ## S3 object key for your PFX certificate
$secretname = "example_secret" ## Gestione dei segreti AWS name for a secret that contains the certificate's password
##
# Set variables
$certfile = "C:\cert.pfx"
$pwd = Get-SECSecretValue -SecretId $secretname | select -expand SecretString
# Clean up existing binding
if ( Get-WebBinding "Default Web Site" -Port 443 ) {
Echo "Removing WebBinding"
Remove-WebBinding -Name "Default Web Site" -BindingInformation *:443:
}
if ( Get-Item -path IIS:\SslBindings\0.0.0.0!443 ) {
Echo "Deregistering WebBinding from IIS"
Remove-Item -path IIS:\SslBindings\0.0.0.0!443
}
# Download certificate from S3
Read-S3Object -BucketName $bucket -Key $certkey -File $certfile
# Install certificate
Echo "Installing cert..."
$securepwd = ConvertTo-SecureString -String $pwd -Force -AsPlainText
$cert = Import-PfxCertificate -FilePath $certfile cert:\localMachine\my -Password $securepwd
# Create site binding
Echo "Creating and registering WebBinding"
New-WebBinding -Name "Default Web Site" -IP "*" -Port 443 -Protocol https
New-Item -path IIS:\SslBindings\0.0.0.0!443 -value $cert -Force
## Remove the HTTP binding
## (optional) Uncomment the following line to unbind port 80
# Remove-WebBinding -Name "Default Web Site" -BindingInformation *:80:
##
# Update firewall
netsh advfirewall firewall add rule name="Open port 443" protocol=TCP localport=443 action=allow dir=OUT
commands:
00_install_ssl:
command: powershell -NoProfile -ExecutionPolicy Bypass -file C:\\certs\\install-cert.ps1
```
In un ambiente con una singola istanza, devi anche modificare il gruppo di sicurezza dell'istanza per consentire il traffico sulla porta 443. Il seguente file di configurazione recupera l'ID del gruppo di sicurezza utilizzando una CloudFormation [funzione](ebextensions-functions.md) e vi aggiunge una regola.
**Example .ebextensions/ https-instance-single .config**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
[Per un ambiente con bilanciamento del carico, è possibile configurare il sistema di bilanciamento del carico in modo da far [passare il traffico sicuro](https-tcp-passthrough.md) in modo inalterato oppure decriptarlo e ricrittografarlo per la crittografia.](configuring-https-endtoend.md) end-to-end
# Configurazione della end-to-end crittografia in un ambiente Elastic Beanstalk con carico bilanciato
L'arresto di connessioni sicure al sistema di bilanciamento del carico e l'utilizzo di HTTP nel back-end potrebbero essere sufficienti per la tua applicazione. Il traffico di rete tra risorse AWS non può essere ascoltato da istanze che non fanno parte della connessione, anche se sono in esecuzione con lo stesso account.
Tuttavia, se sviluppi un'applicazione che deve essere conforme a normative esterne rigorose, potresti dover proteggere tutte le connessioni di rete. Puoi utilizzare la console Elastic Beanstalk o i [file di configurazione](ebextensions.md) per connettere in modo sicuro il sistema di bilanciamento del carico dell'ambiente Elastic Beanstalk alle istanze di back-end e soddisfare questi requisiti. La seguente procedura è incentrata sui file di configurazione.
Anzitutto [aggiungi un listener sicuro al sistema di bilanciamento del carico](configuring-https-elb.md), se non lo hai già fatto.
Devi anche configurare le istanze nell'ambiente perché siano in ascolto sulla porta sicura e terminare le connessioni HTTPS. La configurazione varia in base alla piattaforma. Per istruzioni, consulta [Configurazione della terminazione HTTPS sull'istanza](https-singleinstance.md). Puoi utilizzare un certificato [autofirmato](configuring-https-ssl.md) per le istanze senza problemi. EC2
Configura quindi il listener per inoltrare il traffico tramite HTTPS sulla porta protetta utilizzata dall'applicazione. Utilizza uno dei seguenti file di configurazione, a seconda del tipo di sistema di bilanciamento del carico utilizzato dall'ambiente.
**`.ebextensions/https-reencrypt-clb.config`**
Utilizza questo file di configurazione con un sistema Classic Load Balancer. Oltre a configurare il sistema di bilanciamento del carico, il file di configurazione modifica anche i controlli dello stato predefiniti, in modo che utilizzino la porta 443 e HTTPS per garantire che il sistema di bilanciamento del carico sia in grado di connettersi in modo sicuro.
```
option_settings:
aws:elb:listener:443:
InstancePort: 443
InstanceProtocol: HTTPS
aws:elasticbeanstalk:application:
Application Healthcheck URL: HTTPS:443/
```
**`.ebextensions/https-reencrypt-alb.config`**
Utilizza questo file di configurazione con un sistema Application Load Balancer.
```
option_settings:
aws:elbv2:listener:443:
DefaultProcess: https
ListenerEnabled: 'true'
Protocol: HTTPS
aws:elasticbeanstalk:environment:process:https:
Port: '443'
Protocol: HTTPS
```
**`.ebextensions/https-reencrypt-nlb.config`**
Utilizza questo file di configurazione con un sistema Network Load Balancer.
```
option_settings:
aws:elbv2:listener:443:
DefaultProcess: https
ListenerEnabled: 'true'
aws:elasticbeanstalk:environment:process:https:
Port: '443'
```
L'opzione `DefaultProcess` è così denominata perché un sistema Application Load Balancer può avere listener non predefiniti sulla stessa porta per il traffico verso percorsi specifici (vedi [Application Load Balancer](environments-cfg-alb.md) per i dettagli). Per un sistema Network Load Balancer, l'opzione specifica l'unico processo di destinazione per questo listener.
In questo esempio, abbiamo denominato il processo `https` perché ascolta per proteggere il traffico (HTTPS). Il listener invia il traffico al processo sulla porta designata usando il protocollo TCP perché un sistema Network Load Balancer utilizza solo TCP. Questo comportamento è corretto, perché il traffico di rete HTTP e HTTPS viene implementato su TCP.
**Nota**
La console Elastic Beanstalk e la CLI EB applicano i valori consigliati per le opzioni precedenti. Rimuovi queste impostazioni se desideri utilizzare i file di configurazione per configurare le stesse opzioni. Per informazioni dettagliate, consulta [Valori consigliati](command-options.md#configuration-options-recommendedvalues).
Nell'attività successiva, è necessario modificare il gruppo di sicurezza del sistema di bilanciamento del carico per consentire il traffico. A seconda dell'[Amazon Virtual Private Cloud](https://docs.aws.amazon.com/vpc/latest/userguide/) (Amazon VPC) in cui viene avviato l'ambiente, ovvero il VPC predefinito o un VPC personalizzato, varia il gruppo di sicurezza del sistema di bilanciamento del carico. In un VPC predefinito, Elastic Load Balancing fornisce un gruppo di sicurezza predefinito che può essere utilizzato da tutti i sistemi di bilanciamento del carico. In un Amazon VPC creato da te, Elastic Beanstalk fornisce un gruppo di sicurezza che viene utilizzato dal sistema di bilanciamento del carico.
Per supportare entrambi gli scenari, puoi creare un gruppo di sicurezza e indicare a Elastic Beanstalk di utilizzarlo. Il file di configurazione seguente crea un gruppo di sicurezza e lo collega al sistema di bilanciamento del carico.
**`.ebextensions/https-lbsecuritygroup.config`**
```
option_settings:
# Use the custom security group for the load balancer
aws:elb:loadbalancer:
SecurityGroups: '`{ "Ref" : "loadbalancersg" }`'
ManagedSecurityGroup: '`{ "Ref" : "loadbalancersg" }`'
Resources:
loadbalancersg:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: load balancer security group
VpcId: vpc-########
SecurityGroupIngress:
- IpProtocol: tcp
FromPort: 443
ToPort: 443
CidrIp: 0.0.0.0/0
- IpProtocol: tcp
FromPort: 80
ToPort: 80
CidrIp: 0.0.0.0/0
SecurityGroupEgress:
- IpProtocol: tcp
FromPort: 80
ToPort: 80
CidrIp: 0.0.0.0/0
```
Sostituisci il testo evidenziato con l'ID VPC predefinito o personalizzato. L'esempio precedente include l'ingresso e l'uscita sulla porta 80 per permettere connessioni HTTP. Puoi rimuovere queste proprietà se vuoi permettere solo connessioni sicure.
Infine, aggiungi regole di ingresso e di uscita per permettere la comunicazione sulla porta 443 tra il gruppo di sicurezza del sistema di bilanciamento del carico e il gruppo di sicurezza delle istanze.
**`.ebextensions/https-backendsecurity.config`**
```
Resources:
# Add 443-inbound to instance security group (AWSEBSecurityGroup)
httpsFromLoadBalancerSG:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
SourceSecurityGroupId: {"Fn::GetAtt" : ["loadbalancersg", "GroupId"]}
# Add 443-outbound to load balancer security group (loadbalancersg)
httpsToBackendInstances:
Type: AWS::EC2::SecurityGroupEgress
Properties:
GroupId: {"Fn::GetAtt" : ["loadbalancersg", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
DestinationSecurityGroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
```
Eseguendo questa operazione separatamente dalla creazione del gruppo di sicurezza, potrai limitare i gruppi di sicurezza di origine e destinazione senza creare una dipendenza circolare.
Una volta completate tutte le attività sopra descritte, il sistema di bilanciamento del carico si connette alle istanze di back-end in modo sicuro utilizzando HTTPS. Al sistema di bilanciamento del carico non importa se il certificato dell'istanza è autofirmato o rilasciato da un'autorità di certificazione attendibile, ma accetta semplicemente qualsiasi certificato presentato.
Puoi modificare questo comportamento aggiungendo delle policy al sistema di bilanciamento del carico che gli indichino come attendibile un solo certificato specifico. Il file di configurazione seguente crea due policy. Una policy specifica un certificato pubblico e l'altra indica al sistema di bilanciamento del carico di considerare affidabile solo il certificato per le connessioni alla porta 443 dell'istanza.
**`.ebextensions/https-backendauth.config`**
```
option_settings:
# Backend Encryption Policy
aws:elb:policies:backendencryption:
PublicKeyPolicyNames: backendkey
InstancePorts: 443
# Public Key Policy
aws:elb:policies:backendkey:
PublicKey: |
-----BEGIN CERTIFICATE-----
################################################################
################################################################
################################################################
################################################################
################################################
-----END CERTIFICATE-----
```
Sostituisci il testo evidenziato con il contenuto del certificato pubblico dell' EC2 istanza.
# Configurazione del sistema di bilanciamento del carico dell'ambiente per il passthrough TCP
Se non desideri che il sistema di bilanciamento del carico del tuo AWS Elastic Beanstalk ambiente decrittografi il traffico HTTPS, puoi configurare il listener sicuro per inoltrare le richieste alle istanze di backend così come sono.
**Importante**
La configurazione del load balancer per inoltrare il traffico HTTPS senza decrittografarlo presenta uno svantaggio. Il load balancer non è in grado di visualizzare le richieste crittografate e quindi non può ottimizzare il routing o riportare le metriche di risposta.
Per prima cosa [configura le EC2 istanze del tuo ambiente per terminare HTTPS.](https-singleinstance.md) Testa la configurazione su un ambiente di istanza singola per assicurarti che tutto funzioni prima di aggiungere un sistema di bilanciamento del carico alla combinazione.
Aggiungi un [file di configurazione](ebextensions.md) al tuo progetto per configurare un listener sulla porta 443 che trasferisce pacchetti TCP così come sono alla porta 443 sulle istanze di back-end:
**`.ebextensions/https-lb-passthrough.config`**
```
option_settings:
aws:elb:listener:443:
ListenerProtocol: TCP
InstancePort: 443
InstanceProtocol: TCP
```
In un [Amazon Virtual Private Cloud (Amazon VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/) predefinito devi anche aggiungere una regola al gruppo di sicurezza delle istanze per consentire il traffico in entrata sulla porta 443 dal sistema di bilanciamento del carico:
**`.ebextensions/https-instance-securitygroup.config`**
```
Resources:
443inboundfromloadbalancer:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
SourceSecurityGroupName: { "Fn::GetAtt": ["AWSEBLoadBalancer", "SourceSecurityGroup.GroupName"] }
```
In un VPC personalizzato, Elastic Beanstalk aggiorna automaticamente la configurazione del gruppo di sicurezza.
# Configurazione del reindirizzamento da HTTP a HTTPS
Questo argomento descrive come gestire il traffico HTTP verso l'applicazione se gli utenti finali continuano ad avviarlo. A questo scopo, configura il reindirizzamento *da HTTP a HTTPS*, talvolta definito come *forzamento di HTTPS*.
Per configurare il reindirizzamento, è necessario configurare prima l'ambiente per gestire il traffico HTTPS. Quindi reindirizza il traffico HTTP a HTTPS. Queste due fasi sono descritte nelle seguenti sottosezioni.
## Configurare l'ambiente per gestire il traffico HTTPS
A seconda della configurazione del bilanciamento del carico dell'ambiente, effettua una delle seguenti operazioni:
+ **Ambiente con bilanciamento del carico**: [configura il sistema di bilanciamento del carico per terminare HTTPS](configuring-https-elb.md).
+ **Ambiente a istanza singola**: [configura la tua applicazione per terminare le connessioni HTTPS nell'istanza](https-singleinstance.md). Questa configurazione dipende dalla piattaforma dell'ambiente.
## Reindirizzare il traffico HTTP a HTTPS
Per reindirizzare il traffico HTTP verso HTTPS per la tua applicazione, puoi configurare i server Web sulle istanze del tuo ambiente oppure configurare l'Application Load Balancer dell'ambiente.
**Configura i server web dell'istanza**
Questo metodo funziona su qualsiasi ambiente di server Web. Configura i server Web sulle tue EC2 istanze Amazon per rispondere al traffico HTTP con uno stato di risposta di reindirizzamento HTTP.
Questa configurazione dipende dalla piattaforma dell'ambiente. Trova la cartella per la tua piattaforma nella [https://github.com/awsdocs/elastic-beanstalk-samples/tree/master/configuration-files/aws-provided/security-configuration/https-redirect](https://github.com/awsdocs/elastic-beanstalk-samples/tree/master/configuration-files/aws-provided/security-configuration/https-redirect)raccolta su GitHub e usa il file di configurazione di esempio contenuto in quella cartella.
Se l'ambiente utilizza i [controlli dello stato di Elastic Load Balancing](using-features.healthstatus.md#using-features.healthstatus.understanding), il sistema di bilanciamento del carico richiede un'istanza integra per rispondere ai messaggi di controllo dello stato HTTP con risposte HTTP 200 (OK). Di conseguenza, il server Web non deve reindirizzare questi messaggi ad HTTPS. I file di configurazione di esempio in [https://github.com/awsdocs/elastic-beanstalk-samples/tree/master/configuration-files/aws-provided/security-configuration/https-redirect](https://github.com/awsdocs/elastic-beanstalk-samples/tree/master/configuration-files/aws-provided/security-configuration/https-redirect) gestiscono questo requisito correttamente.
**Configura il sistema di bilanciamento del carico**
Questo metodo funziona se si dispone di un ambiente con carico bilanciato che utilizza un Application Load [Balancer](environments-cfg-alb.md). Un Application Load Balancer può inviare risposte di reindirizzamento man mano che arriva il traffico HTTP. In questo caso, non è necessario configurare il reindirizzamento sulle istanze dell'ambiente.
Abbiamo due file di configurazione di esempio GitHub che mostrano come configurare un Application Load Balancer per il reindirizzamento.
+ Il file di configurazione [https://github.com/awsdocs/elastic-beanstalk-samples/blob/master/configuration-files/aws-provided/resource-configuration/alb-http-to-https-redirection-full.config](https://github.com/awsdocs/elastic-beanstalk-samples/blob/master/configuration-files/aws-provided/resource-configuration/alb-http-to-https-redirection-full.config) crea un listener HTTPS sulla porta 443 e modifica il listener predefinito della porta 80 per reindirizzare il traffico HTTP in ingresso a HTTPS.
+ Il file [https://github.com/awsdocs/elastic-beanstalk-samples/blob/master/configuration-files/aws-provided/resource-configuration/alb-http-to-https-redirection.config](https://github.com/awsdocs/elastic-beanstalk-samples/blob/master/configuration-files/aws-provided/resource-configuration/alb-http-to-https-redirection.config)di configurazione prevede la definizione del listener 443. Per definirlo, puoi utilizzare i namespace di configurazione Elastic Beanstalk standard o la console Elastic Beanstalk. Quindi apporta la modifica al listener della porta 80 per il reindirizzamento.