id
stringlengths 14
16
| text
stringlengths 1
2.43k
| source
stringlengths 99
229
|
|---|---|---|
b3d9e3e501b4-0 | You can create multi\-volume snapshots, which are point\-in\-time snapshots for all EBS volumes attached to an EC2 instance\. You can also create lifecycle policies to automate the creation and retention of multi\-volume snapshots\. For more information, see [Automating the Amazon EBS snapshot lifecycle](snapshot-lifecycle.md)\.
After the snapshots are created, each snapshot is treated as an individual snapshot\. You can perform all snapshot operations, such as restore, delete, and copy across Regions or accounts, just as you would with a single volume snapshot\. You can also tag your multi\-volume snapshots as you would a single volume snapshot\. We recommend you tag your multiple volume snapshots to manage them collectively during restore, copy, or retention\.
Multi\-volume, crash\-consistent snapshots are typically restored as a set\. It is helpful to identify the snapshots that are in a crash\-consistent set by tagging your set with the instance ID, name, or other relevant details\. You can also choose to automatically copy tags from the source volume to the corresponding snapshots\. This helps you to set the snapshot metadata, such as access policies, attachment information, and cost allocation, to match the source volume\.
After it's created, a multi\-volume snapshot behaves like any other snapshot\. You can perform all operations, such as restore, delete, and copy across Regions and accounts\. You can also tag your snapshots\. We recommend that you tag your multi\-volume snapshots to collectively manage them during restore, copy, or retention\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ebs-creating-snapshot.md |
b3d9e3e501b4-1 | After creating your snapshots, they appear in your EC2 console created at the exact point\-in\-time\. The snapshots are collectively managed and, therefore, if any one snapshot for the volume set fails, all of the other snapshots display an error status\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ebs-creating-snapshot.md |
08ed16c822aa-0 | You can create, retain, and delete snapshots manually, or you can use Amazon Data Lifecycle Manager to manage your snapshots for you\. For more information, see [Automating snapshots](snapshot-lifecycle.md)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ebs-creating-snapshot.md |
54145edea051-0 | The following considerations apply to creating snapshots:
+ When you create a snapshot for an EBS volume that serves as a root device, you should stop the instance before taking the snapshot\.
+ You cannot create snapshots from instances for which hibernation is enabled\.
+ You cannot create snapshots from hibernated instances\.
+ Although you can take a snapshot of a volume while a previous snapshot of that volume is in the `pending` status, having multiple `pending` snapshots of a volume can result in reduced volume performance until the snapshots complete\.
+ There is a limit of five `pending` snapshots for a single `gp2`, `io1`, `io2`, or Magnetic volume, and one `pending` snapshot for a single `st1` or `sc1` volume\. If you receive a `ConcurrentSnapshotLimitExceeded` error while trying to create multiple concurrent snapshots of the same volume, wait for one or more of the `pending` snapshots to complete before creating another snapshot of that volume\.
+ When a snapshot is created from a volume with an AWS Marketplace product code, the product code is propagated to the snapshot\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ebs-creating-snapshot.md |
7385c74eca77-0 | Use the following procedure to create a snapshot from the specified volume\.
**To create a snapshot using the console**
1. Open the Amazon EC2 console at [https://console\.aws\.amazon\.com/ec2/](https://console.aws.amazon.com/ec2/)\.
1. Choose **Snapshots** under **Elastic Block Store** in the navigation pane\.
1. Choose **Create Snapshot**\.
1. For **Select resource type**, choose **Volume**\.
1. For **Volume**, select the volume\.
1. \(Optional\) Enter a description for the snapshot\.
1. \(Optional\) Choose **Add Tag** to add tags to your snapshot\. For each tag, provide a tag key and a tag value\.
1. Choose **Create Snapshot**\.
**To create a snapshot using the command line**
You can use one of the following commands\. For more information about these command line interfaces, see [Accessing Amazon EC2](concepts.md#access-ec2)\.
+ [create\-snapshot](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-snapshot.html) \(AWS CLI\) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ebs-creating-snapshot.md |
7385c74eca77-1 | + [New\-EC2Snapshot](https://docs.aws.amazon.com/powershell/latest/reference/items/New-EC2Snapshot.html) \(AWS Tools for Windows PowerShell\) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ebs-creating-snapshot.md |
aaae620af4a7-0 | Use the following procedure to create a snapshot from the volumes of an instance\.
**To create multi\-volume snapshots using the console**
1. Open the Amazon EC2 console at [https://console\.aws\.amazon\.com/ec2/](https://console.aws.amazon.com/ec2/)\.
1. Choose **Snapshots** under **Elastic Block Store** in the navigation pane\.
1. Choose **Create Snapshot**\.
1. For **Select resource type**, choose **Instance**\.
1. Select the instance ID for which you want to create simultaneous backups for all of the attached EBS volumes\. Multi\-volume snapshots support up to 40 EBS volumes per instance\.
1. \(Optional\) Set **Exclude root volume**\.
1. \(Optional\) Set **Copy tags from volume** flag to automatically copy tags from the source volume to the corresponding snapshots\. This sets snapshot metadata—such as access policies, attachment information, and cost allocation—to match the source volume\.
1. \(Optional\) Choose **Add Tag** to add tags to your snapshot\. For each tag, provide a tag key and a tag value\.
1. Choose **Create Snapshot**\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ebs-creating-snapshot.md |
aaae620af4a7-1 | 1. Choose **Create Snapshot**\.
During snapshot creation, the snapshots are managed together\. If one of the snapshots in the volume set fails, the other snapshots are moved to error status for the volume set\. You can monitor the progress of your snapshots using [CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html)\. After the snapshot creation process completes, CloudWatch generates an event that contains the status and all of the relevant snapshots details for the affected instance\.
**To create multi\-volume snapshots using the command line**
You can use one of the following commands\. For more information about these command line interfaces, see [Accessing Amazon EC2](concepts.md#access-ec2)\.
+ [create\-snapshots](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-snapshots.html) \(AWS CLI\)
+ [New\-EC2SnapshotBatch](https://docs.aws.amazon.com/powershell/latest/reference/items/New-EC2SnapshotBatch.html) \(AWS Tools for Windows PowerShell\) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ebs-creating-snapshot.md |
0588f5126129-0 | You can copy snapshots, share snapshots, and create volumes from snapshots\. For more information, see the following:
+ [Copying an Amazon EBS snapshot](ebs-copy-snapshot.md)
+ [Sharing an Amazon EBS snapshot](ebs-modifying-snapshot-permissions.md)
+ [Creating a volume from a snapshot](ebs-creating-volume.md#ebs-create-volume-from-snapshot) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ebs-creating-snapshot.md |
3a8543096dac-0 | Secure Sockets Layer/Transport Layer Security \(SSL/TLS\) creates an encrypted channel between a web server and web client that protects data in transit from being eavesdropped on\. This tutorial explains how to add support manually for SSL/TLS on an EC2 instance with the Amazon Linux AMI and Apache web server\. If you plan to offer commercial\-grade services, the [AWS Certificate Manager](https://aws.amazon.com/certificate-manager/), which is not discussed here, is a good option\.
For historical reasons, web encryption is often referred to simply as SSL\. While web browsers still support SSL, its successor protocol TLS is less vulnerable to attack\. The Amazon Linux AMI disables server\-side support all versions of SSL by default\. [Security standards bodies](https://www.ssl.com/article/deprecating-early-tls/) consider TLS 1\.0 to be unsafe, and both TLS 1\.0 and TLS 1\.1 are on track to be formally [deprecated](https://tools.ietf.org/html/draft-ietf-tls-oldversions-deprecate-03) by the IETF\. This tutorial contains guidance based exclusively on enabling TLS 1\.2\. \(A newer TLS 1\.3 protocol exists in draft form, but is not supported on Amazon Linux\.\) For more information about the updated encryption standards, see [RFC 7568](https://tools.ietf.org/html/rfc7568) and [RFC 8446](https://tools.ietf.org/html/rfc8446)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
3a8543096dac-1 | This tutorial refers to modern web encryption simply as TLS\.
**Important**
These procedures are intended for use with the Amazon Linux AMI\. If you are trying to set up a LAMP web server on an instance with a different distribution, some procedures in this tutorial might not work for you\. For information about LAMP web servers on Ubuntu, see the Ubuntu community documentation [ApacheMySQLPHP](https://help.ubuntu.com/community/ApacheMySQLPHP)\. For information about Red Hat Enterprise Linux, see the Customer Portal documentation [Web Servers](https://access.redhat.com/documentation/en-US/Red_Hat_Enterprise_Linux/7/html/System_Administrators_Guide/ch-Web_Servers.html)\.
**Topics**
+ [Prerequisites](#ssl-prereq-alami)
+ [Step 1: Enable TLS on the server](#ssl-enable-alami)
+ [Step 2: Obtain a CA\-signed certificate](#ssl-certificate-alami)
+ [Step 3: Test and harden the security configuration](#ssl-test-alami)
+ [Troubleshooting](#troubleshooting-alami)
+ [Certificate automation: Let's Encrypt with Certbot on Amazon Linux](#lets-encrypt-alami) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
49ac5c28630c-0 | Before you begin this tutorial, complete the following steps:
+ Launch an EBS\-backed instance using the Amazon Linux AMI\. For more information, see [Step 1: Launch an instance](EC2_GetStarted.md#ec2-launch-instance)\.
+ Configure your security group to allow your instance to accept connections on the following TCP ports:
+ SSH \(port 22\)
+ HTTP \(port 80\)
+ HTTPS \(port 443\)
For more information, see [Authorizing inbound traffic for your Linux instances](authorizing-access-to-an-instance.md)\.
+ Install Apache web server\. For step\-by\-step instructions, see [Tutorial: Installing a LAMP Web Server on Amazon Linux](install-LAMP.md)\. Only the http24 package and its dependencies are needed; you can ignore the instructions involving PHP and MySQL\.
+ To identify and authenticate web sites, the TLS public key infrastructure \(PKI\) relies on the Domain Name System \(DNS\)\. To use your EC2 instance to host a public web site, you need to register a domain name for your web server or transfer an existing domain name to your Amazon EC2 host\. Numerous third\-party domain registration and DNS hosting services are available for this, or you can use [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
e3fb0167c947-0 | This procedure takes you through the process of setting up TLS on Amazon Linux with a self\-signed digital certificate\.
**Note**
A self\-signed certificate is acceptable for testing but not production\. If you expose your self\-signed certificate to the internet, visitors to your site receive security warnings\.
**To enable TLS on a server**
1. [Connect to your instance](EC2_GetStarted.md#ec2-connect-to-instance-linux) and confirm that Apache is running\.
```
[ec2-user ~]$ sudo service httpd status
```
If necessary, start Apache\.
```
[ec2-user ~]$ sudo service httpd start
```
1. To ensure that all of your software packages are up to date, perform a quick software update on your instance\. This process may take a few minutes, but it is important to make sure you have the latest security updates and bug fixes\.
**Note**
The `-y` option installs the updates without asking for confirmation\. If you would like to examine the updates before installing, you can omit this option\.
```
[ec2-user ~]$ sudo yum update -y
```
1. Now that your instance is current, add TLS support by installing the Apache module `mod_ssl`:
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
e3fb0167c947-1 | 1. Now that your instance is current, add TLS support by installing the Apache module `mod_ssl`:
```
[ec2-user ~]$ sudo yum install -y mod24_ssl
```
Your instance now has the following files that you use to configure your secure server and create a certificate for testing:
`/etc/httpd/conf.d/ssl.conf`
The configuration file for mod\_ssl\. It contains "directives" telling Apache where to find encryption keys and certificates, the TLS protocol versions to allow, and the encryption ciphers to accept\.
`/etc/pki/tls/private/localhost.key`
An automatically generated, 2048\-bit RSA private key for your Amazon EC2 host\. During installation, OpenSSL used this key to generate a self\-signed host certificate, and you can also use this key to generate a certificate signing request \(CSR\) to submit to a certificate authority \(CA\)\.
`/etc/pki/tls/certs/localhost.crt`
An automatically generated, self\-signed X\.509 certificate for your server host\. This certificate is useful for testing that Apache is properly set up to use TLS\.
The `.key` and `.crt` files are both in PEM format, which consists of Base64\-encoded ASCII characters framed by "BEGIN" and "END" lines, as in this abbreviated example of a certificate:
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
e3fb0167c947-2 | ```
-----BEGIN CERTIFICATE-----
MIIEazCCA1OgAwIBAgICWxQwDQYJKoZIhvcNAQELBQAwgbExCzAJBgNVBAYTAi0t
MRIwEAYDVQQIDAlTb21lU3RhdGUxETAPBgNVBAcMCFNvbWVDaXR5MRkwFwYDVQQK
DBBTb21lT3JnYW5pemF0aW9uMR8wHQYDVQQLDBZTb21lT3JnYW5pemF0aW9uYWxV
bml0MRkwFwYDVQQDDBBpcC0xNzItMzEtMjAtMjM2MSQwIgYJKoZIhvcNAQkBFhVy
...
z5rRUE/XzxRLBZOoWZpNWTXJkQ3uFYH6s/sBwtHpKKZMzOvDedREjNKAvk4ws6F0
WanXWehT6FiSZvB4sTEXXJN2jdw8g+sHGnZ8zCOsclknYhHrCVD2vnBlZJKSZvak
3ZazhBxtQSukFMOnWPP2a0DMMFGYUHOd0BQE8sBJxg==
-----END CERTIFICATE-----
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
e3fb0167c947-3 | -----END CERTIFICATE-----
```
The file names and extensions are a convenience and have no effect on function; you can call a certificate `cert.crt`, `cert.pem`, or any other file name, so long as the related directive in the `ssl.conf` file uses the same name\.
**Note**
When you replace the default TLS files with your own customized files, be sure that they are in PEM format\.
1. Restart Apache\.
```
[ec2-user ~]$ sudo service httpd restart
```
1. Your Apache web server should now support HTTPS \(secure HTTP\) over port 443\. Test it by typing the IP address or fully qualified domain name of your EC2 instance into a browser URL bar with the prefix **https://**\. Because you are connecting to a site with a self\-signed, untrusted host certificate, your browser may display a series of security warnings\.
Override the warnings and proceed to the site\. If the default Apache test page opens, it means that you have successfully configured TLS on your server\. All data passing between the browser and server is now safely encrypted\.
To prevent site visitors from encountering warning screens, you need to obtain a certificate that not only encrypts, but also publicly authenticates you as the owner of the site\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
4e11a48fb03f-0 | You can use the following process to obtain a CA\-signed certificate:
+ Generate a certificate signing request \(CSR\) from a private key
+ Submit the CSR to a certificate authority \(CA\)
+ Obtain a signed host certificate
+ Configure Apache to use the certificate
A self\-signed TLS X\.509 host certificate is cryptologically identical to a CA\-signed certificate\. The difference is social, not mathematical; a CA promises to validate, at a minimum, a domain's ownership before issuing a certificate to an applicant\. Each web browser contains a list of CAs trusted by the browser vendor to do this\. An X\.509 certificate consists primarily of a public key that corresponds to your private server key, and a signature by the CA that is cryptographically tied to the public key\. When a browser connects to a web server over HTTPS, the server presents a certificate for the browser to check against its list of trusted CAs\. If the signer is on the list, or accessible through a chain of trust consisting of other trusted signers, the browser negotiates a fast encrypted data channel with the server and loads the page\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
4e11a48fb03f-1 | Certificates generally cost money because of the labor involved in validating the requests, so it pays to shop around\. A list of well\-known CAs can be found at [dmoztools\.net](http://dmoztools.net/Computers/Security/Public_Key_Infrastructure/PKIX/Tools_and_Services/Third_Party_Certificate_Authorities/)\. A few CAs offer basic\-level certificates free of charge\. The most notable of these is the [Let's Encrypt](https://letsencrypt.org/) project, which also supports automation of the certificate creation and renewal process\. For more information about using Let's Encrypt as your CA, see [Certificate automation: Let's Encrypt with Certbot on Amazon Linux](#lets-encrypt-alami)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
4e11a48fb03f-2 | Underlying the host certificate is the key\. As of 2017, [government](http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-57pt1r4.pdf) and [industry](https://cabforum.org/wp-content/uploads/CA-Browser-Forum-BR-1.4.2.pdf) groups recommend using a minimum key \(modulus\) size of 2048 bits for RSA keys intended to protect documents through 2030\. The default modulus size generated by OpenSSL in Amazon Linux is 2048 bits, which means that the existing auto\-generated key is suitable for use in a CA\-signed certificate\. An alternative procedure is described below for those who desire a customized key, for instance, one with a larger modulus or using a different encryption algorithm\.
These instructions for acquiring a CA\-signed host certificate do not work unless you own a registered and hosted DNS domain\.
**To obtain a CA\-signed certificate**
1. [Connect to your instance](EC2_GetStarted.md#ec2-connect-to-instance-linux) and navigate to /etc/pki/tls/private/\. This is the directory where the server's private key for TLS is stored\. If you prefer to use your existing host key to generate the CSR, skip to Step 3\.
1. \(Optional\) Generate a new private key\. Here are some examples of key configurations\. Any of the resulting keys work with your web server, but they vary in how \(and how much\) security they implement\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
4e11a48fb03f-3 | + **Example 1:** Create a default RSA host key\. The resulting file, **custom\.key**, is a 2048\-bit RSA private key\.
```
[ec2-user ~]$ sudo openssl genrsa -out custom.key
```
+ **Example 2:** Create a stronger RSA key with a bigger modulus\. The resulting file, **custom\.key**, is a 4096\-bit RSA private key\.
```
[ec2-user ~]$ sudo openssl genrsa -out custom.key 4096
```
+ **Example 3:** Create a 4096\-bit encrypted RSA key with password protection\. The resulting file, **custom\.key**, is a 4096\-bit RSA private key encrypted with the AES\-128 cipher\.
**Important**
Encrypting the key provides greater security, but because an encrypted key requires a password, services depending on it cannot be auto\-started\. Each time you use this key, you must supply the password \(in the preceding example, "abcde12345"\) over an SSH connection\.
```
[ec2-user ~]$ sudo openssl genrsa -aes128 -passout pass:abcde12345 -out custom.key 4096
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
4e11a48fb03f-4 | ```
+ **Example 4:** Create a key using a non\-RSA cipher\. RSA cryptography can be relatively slow because of the size of its public keys, which are based on the product of two large prime numbers\. However, it is possible to create keys for TLS that use non\-RSA ciphers\. Keys based on the mathematics of elliptic curves are smaller and computationally faster when delivering an equivalent level of security\.
```
[ec2-user ~]$ sudo openssl ecparam -name prime256v1 -out custom.key -genkey
```
The result is a 256\-bit elliptic curve private key using prime256v1, a "named curve" that OpenSSL supports\. Its cryptographic strength is slightly greater than a 2048\-bit RSA key, [according to NIST](http://csrc.nist.gov/publications/nistpubs/800-57/sp800-57_part1_rev3_general.pdf)\.
**Note**
Not all CAs provide the same level of support for elliptic\-curve\-based keys as for RSA keys\.
Make sure that the new private key has highly restrictive ownership and permissions \(owner=root, group=root, read/write for owner only\)\. The commands would be as follows:
```
[ec2-user ~]$ sudo chown root.root custom.key
[ec2-user ~]$ sudo chmod 600 custom.key | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
4e11a48fb03f-5 | [ec2-user ~]$ sudo chmod 600 custom.key
[ec2-user ~]$ ls -al custom.key
```
The commands above should yield the following result:
```
-rw------- root root custom.key
```
After you have created and configured a satisfactory key, you can create a CSR\.
1. Create a CSR using your preferred key; the example below uses **custom\.key**:
```
[ec2-user ~]$ sudo openssl req -new -key custom.key -out csr.pem
```
OpenSSL opens a dialog and prompts you for the information shown in the following table\. All of the fields except **Common Name** are optional for a basic, domain\-validated host certificate\.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/SSL-on-amazon-linux-ami.html)
Finally, OpenSSL prompts you for an optional challenge password\. This password applies only to the CSR and to transactions between you and your CA, so follow the CA's recommendations about this and the other optional field, optional company name\. The CSR challenge password has no effect on server operation\.
The resulting file **csr\.pem** contains your public key, your digital signature of your public key, and the metadata that you entered\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
4e11a48fb03f-6 | The resulting file **csr\.pem** contains your public key, your digital signature of your public key, and the metadata that you entered\.
1. Submit the CSR to a CA\. This usually consists of opening your CSR file in a text editor and copying the contents into a web form\. At this time, you may be asked to supply one or more subject alternate names \(SANs\) to be placed on the certificate\. If **www\.example\.com** is the common name, then **example\.com** would be a good SAN, and vice versa\. A visitor to your site typing in either of these names would see an error\-free connection\. If your CA web form allows it, include the common name in the list of SANs\. Some CAs include it automatically\.
After your request has been approved, you receive a new host certificate signed by the CA\. You might also be instructed to download an *intermediate certificate* file that contains additional certificates needed to complete the CA's chain of trust\.
**Note**
Your CA may send you files in multiple formats intended for various purposes\. For this tutorial, you should only use a certificate file in PEM format, which is usually \(but not always\) marked with a `.pem` or `.crt` extension\. If you are uncertain which file to use, open the files with a text editor and find the one containing one or more blocks beginning with the following:
```
- - - - -BEGIN CERTIFICATE - - - - -
```
The file should also end with the following:
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
4e11a48fb03f-7 | ```
The file should also end with the following:
```
- - - -END CERTIFICATE - - - - -
```
You can also test a file at the command line as follows:
```
[ec2-user certs]$ openssl x509 -in certificate.crt -text
```
Verify that these lines appear in the file\. Do not use files ending with `.p7b`, `.p7c`, or similar file extensions\.
1. Place the new CA\-signed certificate and any intermediate certificates in the `/etc/pki/tls/certs` directory\.
**Note**
There are several ways to upload your custom key to your EC2 instance, but the most straightforward and informative way is to open a text editor \(for example, vi, nano, or notepad\) on both your local computer and your instance, and then copy and paste the file contents between them\. You need root \[sudo\] permissions when performing these operations on the EC2 instance\. This way, you can see immediately if there are any permission or path problems\. Be careful, however, not to add any additional lines while copying the contents, or to change them in any way\.
From inside the `/etc/pki/tls/certs` directory, use the following commands to verify that the file ownership, group, and permission settings match the highly restrictive Amazon Linux defaults \(owner=root, group=root, read/write for owner only\)\.
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
4e11a48fb03f-8 | ```
[ec2-user certs]$ sudo chown root.root custom.crt
[ec2-user certs]$ sudo chmod 600 custom.crt
[ec2-user certs]$ ls -al custom.crt
```
The commands above should yield the following result:
```
-rw------- root root custom.crt
```
The permissions for the intermediate certificate file are less stringent \(owner=root, group=root, owner can write, group can read, world can read\)\. The commands would be:
```
[ec2-user certs]$ sudo chown root.root intermediate.crt
[ec2-user certs]$ sudo chmod 644 intermediate.crt
[ec2-user certs]$ ls -al intermediate.crt
```
The commands above should yield the following result:
```
-rw-r--r-- root root intermediate.crt
```
1. If you used a custom key to create your CSR and the resulting host certificate, remove or rename the old key from the `/etc/pki/tls/private/` directory, and then install the new key there\.
**Note** | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
4e11a48fb03f-9 | **Note**
There are several ways to upload your custom key to your EC2 instance, but the most straightforward and informative way is to open a text editor \(vi, nano, notepad, etc\.\) on both your local computer and your instance, and then copy and paste the file contents between them\. You need root \[sudo\] privileges when performing these operations on the EC2 instance\. This way, you can see immediately if there are any permission or path problems\. Be careful, however, not to add any additional lines while copying the contents, or to change them in any way\.
From inside the `/etc/pki/tls/private` directory, check that the file ownership, group, and permission settings match the highly restrictive Amazon Linux defaults \(owner=root, group=root, read/write for owner only\)\. The commands would be as follows:
```
[ec2-user private]$ sudo chown root.root custom.key
[ec2-user private]$ sudo chmod 600 custom.key
[ec2-user private]$ ls -al custom.key
```
The commands above should yield the following result:
```
-rw------- root root custom.key
```
1. Edit `/etc/httpd/conf.d/ssl.conf` to reflect your new certificate and key files\.
1. Provide the path and file name of the CA\-signed host certificate in Apache's `SSLCertificateFile` directive: | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
4e11a48fb03f-10 | 1. Provide the path and file name of the CA\-signed host certificate in Apache's `SSLCertificateFile` directive:
```
SSLCertificateFile /etc/pki/tls/certs/custom.crt
```
1. If you received an intermediate certificate file \(`intermediate.crt` in this example\), provide its path and file name using Apache's `SSLCACertificateFile` directive:
```
SSLCACertificateFile /etc/pki/tls/certs/intermediate.crt
```
**Note**
Some CAs combine the host certificate and the intermediate certificates in a single file, making this directive unnecessary\. Consult the instructions provided by your CA\.
1. Provide the path and file name of the private key in Apache's `SSLCertificateKeyFile` directive:
```
SSLCertificateKeyFile /etc/pki/tls/private/custom.key
```
1. Save `/etc/httpd/conf.d/ssl.conf` and restart Apache\.
```
[ec2-user ~]$ sudo service httpd restart
```
1. Test your server by entering your domain name into a browser URL bar with the prefix `https://`\. Your browser should load the test page over HTTPS without generating errors\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
e51aa4e37cb5-0 | After your TLS is operational and exposed to the public, you should test how secure it really is\. This is easy to do using online services such as [Qualys SSL Labs](https://www.ssllabs.com/ssltest/analyze.html), which performs a free and thorough analysis of your security setup\. Based on the results, you may decide to harden the default security configuration by controlling which protocols you accept, which ciphers you prefer, and which you exclude\. For more information, see [how Qualys formulates its scores](https://github.com/ssllabs/research/wiki/SSL-Server-Rating-Guide)\.
**Important**
Real\-world testing is crucial to the security of your server\. Small configuration errors may lead to serious security breaches and loss of data\. Because recommended security practices change constantly in response to research and emerging threats, periodic security audits are essential to good server administration\.
On the [Qualys SSL Labs](https://www.ssllabs.com/ssltest/analyze.html) site, type the fully qualified domain name of your server, in the form **www\.example\.com**\. After about two minutes, you receive a grade \(from A to F\) for your site and a detailed breakdown of the findings\. Though the overview shows that the configuration is mostly sound, the detailed report flags several potential problems\. For example: | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
e51aa4e37cb5-1 | ✗ **The RC4 cipher is supported for use by certain older browsers\.** A cipher is the mathematical core of an encryption algorithm\. RC4, a fast cipher used to encrypt TLS data\-streams, is known to have several [serious weaknesses](http://www.imperva.com/docs/hii_attacking_ssl_when_using_rc4.pdf)\. Unless you have very good reasons to support legacy browsers, you should disable this\.
✗ **Old TLS versions are supported\.** The configuration supports TLS 1\.0 \(already deprecated\) and TLS 1\.1 \(on a path to deprecation\)\. Only TLS 1\.2 has been recommended since 2018\.
**To correct the TLS configuration**
1. Open the configuration file `/etc/httpd/conf.d/ssl.conf` in a text editor and comment out the following lines by typing "\#" at the beginning of each:
```
#SSLProtocol all -SSLv3
#SSLProxyProtocol all -SSLv3
```
1. Add the following directives:
```
SSLProtocol -SSLv2 -SSLv3 -TLSv1 -TLSv1.1 +TLSv1.2
SSLProxyProtocol -SSLv2 -SSLv3 -TLSv1 -TLSv1.1 +TLSv1.2
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
e51aa4e37cb5-2 | ```
These directives explicitly disable SSL versions 2 and 3, as well as TLS versions 1\.0 and 1\.1\. The server now refuses to accept encrypted connections with clients using anything except TLS 1\.2\. The verbose wording in the directive communicates more clearly, to a human reader, what the server is configured to do\.
**Note**
Disabling TLS versions 1\.0 and 1\.1 in this manner blocks a small percentage of outdated web browsers from accessing your site\.
**To modify the list of allowed ciphers**
1. Open the configuration file `/etc/httpd/conf.d/ssl.conf` and find the section with commented\-out examples for configuring **SSLCipherSuite** and **SSLProxyCipherSuite**\.
```
#SSLCipherSuite HIGH:MEDIUM:!aNULL:!MD5
#SSLProxyCipherSuite HIGH:MEDIUM:!aNULL:!MD5
```
Leave these as they are, and below them add the following directives:
**Note**
Though shown here on several lines for readability, each of these two directives must be on a single line without spaces between the cipher names\.
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
e51aa4e37cb5-3 | Though shown here on several lines for readability, each of these two directives must be on a single line without spaces between the cipher names\.
```
SSLCipherSuite ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:
ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-SHA384:
ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:AES:!aNULL:!eNULL:!EXPORT:!DES:
!RC4:!MD5:!PSK:!aECDH:!EDH-DSS-DES-CBC3-SHA:!EDH-RSA-DES-CBC3-SHA:!KRB5-DES-CBC3-SHA
SSLProxyCipherSuite ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305: | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
e51aa4e37cb5-4 | ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-SHA384:
ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:AES:!aNULL:!eNULL:!EXPORT:!DES:
!RC4:!MD5:!PSK:!aECDH:!EDH-DSS-DES-CBC3-SHA:!EDH-RSA-DES-CBC3-SHA:!KRB5-DES-CBC3-SHA
```
These ciphers are a subset of the much longer list of supported ciphers in OpenSSL\. They were selected and ordered according to the following criteria:
+ Support for forward secrecy
+ Strength
+ Speed
+ Specific ciphers before cipher families
+ Allowed ciphers before denied ciphers
Note that the high\-ranking ciphers have *ECDHE* in their names, for *Elliptic Curve Diffie\-Hellman Ephemeral *; the *ephemeral* indicates forward secrecy\. Also, RC4 is now among the forbidden ciphers near the end\.
We recommend that you use an explicit list of ciphers instead relying on defaults or terse directives whose content isn't visible\.
**Important** | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
e51aa4e37cb5-5 | We recommend that you use an explicit list of ciphers instead relying on defaults or terse directives whose content isn't visible\.
**Important**
The cipher list shown here is just one of many possible lists; for instance, you might want to optimize a list for speed rather than forward secrecy\.
If you anticipate a need to support older clients, you can allow the DES\-CBC3\-SHA cipher suite\.
Finally, each update to OpenSSL introduces new ciphers and deprecates old ones\. Keep your EC2 Amazon Linux instance up to date, watch for security announcements from [OpenSSL](https://www.openssl.org/), and be alert to reports of new security exploits in the technical press\. For more information, see [Predefined SSL Security Policies for Elastic Load Balancing](https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-security-policy-table.html) in the *User Guide for Classic Load Balancers*\.
1. Uncomment the following line by removing the "\#":
```
#SSLHonorCipherOrder on
```
This command forces the server to prefer high\-ranking ciphers, including \(in this case\) those that support forward secrecy\. With this directive turned on, the server tries to establish a strongly secure connection before falling back to allowed ciphers with lesser security\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
e51aa4e37cb5-6 | 1. Restart Apache\. If you test the domain again on [Qualys SSL Labs](https://www.ssllabs.com/ssltest/analyze.html), you should see that the RC4 vulnerability is gone\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
6c1a43b23fab-0 | + **My Apache webserver won't start unless I supply a password**
This is expected behavior if you installed an encrypted, password\-protected, private server key\.
You can remove the encryption and password requirement from the key\. Assuming that you have a private encrypted RSA key called `custom.key` in the default directory, and that the password on it is **abcde12345**, run the following commands on your EC2 instance to generate an unencrypted version of the key\.
```
[ec2-user ~]$ cd /etc/pki/tls/private/
[ec2-user private]$ sudo cp custom.key custom.key.bak
[ec2-user private]$ sudo openssl rsa -in custom.key -passin pass:abcde12345 -out custom.key.nocrypt
[ec2-user private]$ sudo mv custom.key.nocrypt custom.key
[ec2-user private]$ sudo chown root.root custom.key
[ec2-user private]$ sudo chmod 600 custom.key
[ec2-user private]$ sudo service httpd restart
```
Apache should now start without prompting you for a password\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
3b3a9e9d7c0b-0 | The [Let's Encrypt](https://letsencrypt.org/) certificate authority is the centerpiece of the Electronic Frontier Foundation \(EFF\) effort to encrypt the entire internet\. In line with that goal, Let's Encrypt host certificates are designed to be created, validated, installed, and maintained with minimal human intervention\. The automated aspects of certificate management are carried out by an agent running on the web server\. After you install and configure the agent, it communicates securely with Let's Encrypt and performs administrative tasks on Apache and the key management system\. This tutorial uses the free [Certbot](https://certbot.eff.org) agent because it allows you either to supply a customized encryption key as the basis for your certificates, or to allow the agent itself to create a key based on its defaults\. You can also configure Certbot to renew your certificates on a regular basis without human interaction, as described in [To automate Certbot](SSL-on-amazon-linux-2.md#automate_certbot)\. For more information, consult the Certbot [User Guide](https://certbot.eff.org/docs/using.html) or [man page](http://manpages.ubuntu.com/manpages/bionic/en/man1/certbot.1.html)\.
Certbot is not officially supported on Amazon Linux AMI, but is available for download and functions correctly when installed\. We recommend that you make the following backups to protect your data and avoid inconvenience: | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
3b3a9e9d7c0b-1 | + Before you begin, take a snapshot of your Amazon EBS root volume\. This allows you to restore the original state of your EC2 instance\. For information about creating EBS snapshots, see [Creating Amazon EBS snapshots](ebs-creating-snapshot.md)\.
+ The procedure below requires you to edit your `httpd.conf` file, which controls Apache's operation\. Certbot makes its own automated changes to this and other configuration files\. Make a backup copy of your entire `/etc/httpd` directory in case you need to restore it\.
**To install and run Certbot**
1. Enable the Extra Packages for Enterprise Linux \(EPEL\) repository from the Fedora project on your instance\. Packages from EPEL are required as dependencies when you run the Certbot installation script\.
```
[ec2-user ~]$ sudo yum-config-manager --enable epel
```
1. Download the latest release of Certbot from EFF onto your EC2 instance using the following command\.
```
[ec2-user ~]$ wget https://dl.eff.org/certbot-auto
```
1. Make the downloaded file executable\.
```
[ec2-user ~]$ chmod a+x certbot-auto
```
1. Run the file with root permissions and the `--debug` flag\.
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
3b3a9e9d7c0b-2 | ```
1. Run the file with root permissions and the `--debug` flag\.
```
[ec2-user ~]$ sudo ./certbot-auto --debug
```
1. At the prompt "Is this ok \[y/d/N\]," type "y" and press Enter\.
1. At the prompt "Enter email address \(used for urgent renewal and security notices\)," type a contact address and press Enter\.
1. Agree to the Let's Encrypt Terms of Service at the prompt\. Type "A" and press Enter to proceed:
```
-------------------------------------------------------------------------------
Please read the Terms of Service at
https://letsencrypt.org/documents/LE-SA-v1.1.1-August-1-2016.pdf. You must agree
in order to register with the ACME server at
https://acme-v01.api.letsencrypt.org/directory | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
3b3a9e9d7c0b-3 | in order to register with the ACME server at
https://acme-v01.api.letsencrypt.org/directory
-------------------------------------------------------------------------------
(A)gree/(C)ancel: A
```
1. Click through the authorization for EFF put you on their mailing list by typing "Y" or "N" and press Enter\.
1. At the prompt shown below, type your Common Name \(the name of your domain as described above\) and your Subject Alternative Name \(SAN\), separating the two names with a space or a comma\. Then press Enter\. In this example, the names have been provided:
```
No names were found in your configuration files. Please enter in your domain
name(s) (comma and/or space separated) (Enter 'c' to cancel):example.com www.example.com
```
1. On an Amazon Linux system with a default Apache configuration, you see output similar to the example below, asking about the first name you provided\. Type "1" and press Enter\.
```
Obtaining a new certificate
Performing the following challenges:
tls-sni-01 challenge for example.com | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
3b3a9e9d7c0b-4 | ```
Obtaining a new certificate
Performing the following challenges:
tls-sni-01 challenge for example.com
tls-sni-01 challenge for www.example.com
We were unable to find a vhost with a ServerName or Address of example.com.
Which virtual host would you like to choose?
(note: conf files with multiple vhosts are not yet supported)
-------------------------------------------------------------------------------
1: ssl.conf | | HTTPS | Enabled
-------------------------------------------------------------------------------
Press 1 [enter] to confirm the selection (press 'c' to cancel): 1
```
1. Next, Certbot asks about the second name\. Type "1" and press Enter\.
```
We were unable to find a vhost with a ServerName or Address of www.example.com.
Which virtual host would you like to choose? | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
3b3a9e9d7c0b-5 | We were unable to find a vhost with a ServerName or Address of www.example.com.
Which virtual host would you like to choose?
(note: conf files with multiple vhosts are not yet supported)
-------------------------------------------------------------------------------
1: ssl.conf | | HTTPS | Enabled
-------------------------------------------------------------------------------
Press 1 [enter] to confirm the selection (press 'c' to cancel): 1
```
At this point, Certbot creates your key and a CSR:
```
Waiting for verification...
Cleaning up challenges
Generating key (2048 bits): /etc/letsencrypt/keys/0000_key-certbot.pem
Creating CSR: /etc/letsencrypt/csr/0000_csr-certbot.pem
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
3b3a9e9d7c0b-6 | Creating CSR: /etc/letsencrypt/csr/0000_csr-certbot.pem
```
1. Authorize Certbot to create and all needed host certificates\. When prompted for each name, type "1" and press Enter as shown in the example:
```
We were unable to find a vhost with a ServerName or Address of example.com.
Which virtual host would you like to choose?
(note: conf files with multiple vhosts are not yet supported)
-------------------------------------------------------------------------------
1: ssl.conf | | HTTPS | Enabled
-------------------------------------------------------------------------------
Press 1 [enter] to confirm the selection (press 'c' to cancel): 1
Deploying Certificate for example.com to VirtualHost /etc/httpd/conf.d/ssl.conf | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
3b3a9e9d7c0b-7 | Deploying Certificate for example.com to VirtualHost /etc/httpd/conf.d/ssl.conf
We were unable to find a vhost with a ServerName or Address of www.example.com.
Which virtual host would you like to choose?
(note: conf files with multiple vhosts are not yet supported)
-------------------------------------------------------------------------------
1: ssl.conf | example.com | HTTPS | Enabled
-------------------------------------------------------------------------------
Press 1 [enter] to confirm the selection (press 'c' to cancel): 1
Deploying Certificate for www.example.com to VirtualHost /etc/httpd/conf.d/ssl.conf
```
1. Choose whether to allow insecure connections to your web server\. If you choose option 2 \(as shown in the example\), all connections to your server will either be encrypted or rejected\.
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
3b3a9e9d7c0b-8 | ```
Please choose whether HTTPS access is required or optional.
-------------------------------------------------------------------------------
1: Easy - Allow both HTTP and HTTPS access to these sites
2: Secure - Make all requests redirect to secure HTTPS access
-------------------------------------------------------------------------------
Select the appropriate number [1-2] then [enter] (press 'c' to cancel): 2
```
Certbot completes the configuration of Apache and reports success and other information:
```
Congratulations! You have successfully enabled https://example.com and
https://www.example.com
You should test your configuration at:
https://www.ssllabs.com/ssltest/analyze.html?d=example.com
https://www.ssllabs.com/ssltest/analyze.html?d=www.example.com | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
3b3a9e9d7c0b-9 | https://www.ssllabs.com/ssltest/analyze.html?d=www.example.com
-------------------------------------------------------------------------------
IMPORTANT NOTES:
- Congratulations! Your certificate and chain have been saved at
/etc/letsencrypt/live/example.com/fullchain.pem. Your cert will
expire on 2017-07-19. To obtain a new or tweaked version of this
certificate in the future, simply run certbot-auto again with the
"certonly" option. To non-interactively renew *all* of your
certificates, run "certbot-auto renew"
....
```
1. After you complete the installation, test and optimize the security of your server as described in [Step 3: Test and harden the security configuration](SSL-on-amazon-linux-2.md#ssl_test)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
3b3a9e9d7c0b-10 | Certbot is designed to become an invisible, error\-resistant part of your server system\. By default, it generates host certificates with a short, 90\-day expiration time\. If you have not previously configured your system to call the command automatically, you must re\-run the certbot command manually\. This procedure shows how to automate Certbot by setting up a cron job\.<a name="automate-certbot-alami"></a>
**To configure automated certificate renewal**
1. Open the `/etc/crontab` file in a text editor, such as vim or nano, using sudo\. Alternatively, use sudo crontab \-e\.
1. Add a line similar to the following and save the file\.
```
39 1,13 * * * root certbot renew --no-self-upgrade
```
Here is an explanation of each component:
`39 1,13 * * *`
Schedules a command to be run at 01:39 and 13:39 every day\. The selected values are arbitrary, but the Certbot developers suggest running the command at least twice daily\. This guarantees that any certificate found to be compromised is promptly revoked and replaced\.
`root`
The command runs with root privileges\.
`certbot renew --no-self-upgrade` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
3b3a9e9d7c0b-11 | `root`
The command runs with root privileges\.
`certbot renew --no-self-upgrade`
The command to be run\. The renew subcommand causes Certbot to check any previously obtained certificates and to renew those that are approaching expiration\. The `--no-self-upgrade` flag prevents Certbot from upgrading itself without your intervention\.
1. Restart the cron daemon:
```
[ec2-user ~]$ sudo service crond restart
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/SSL-on-amazon-linux-ami.md |
64c7ffe61e12-0 | When you purchase a Reserved Instance, you can choose between a Standard or Convertible offering class\. The Reserved Instance applies to a single instance type, platform, scope, and tenancy over a term\. If your computing needs change, you may be able to modify or exchange your Reserved Instance, depending on the offering class\. Offering classes may also have additional restrictions or limitations\.
The following are the differences between Standard and Convertible offering classes\.
| Standard Reserved Instance | Convertible Reserved Instance |
| --- | --- |
| Some attributes, such as instance size, can be modified during the term; however, the instance family cannot be modified\. You cannot exchange a Standard Reserved Instance, only modify it\. For more information, see [Modifying Reserved Instances](ri-modifying.md)\. | Can be exchanged during the term for another Convertible Reserved Instance with new attributes including instance family, instance type, platform, scope, or tenancy\. For more information, see [Exchanging Convertible Reserved Instances](ri-convertible-exchange.md)\. You can also modify some attributes of a Convertible Reserved Instance\. For more information, see [Modifying Reserved Instances](ri-modifying.md)\. |
| Can be sold in the Reserved Instance Marketplace\. | Cannot be sold in the Reserved Instance Marketplace\. |
Standard and Convertible Reserved Instances can be purchased to apply to instances in a specific Availability Zone \(zonal Reserved Instances\), or to instances in a Region \(regional Reserved Instances\)\. For more information and examples, see [How Reserved Instances are applied](apply_ri.md)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/reserved-instances-types.md |
64c7ffe61e12-1 | If you want to purchase capacity reservations that recur on a daily, weekly, or monthly basis, a Scheduled Reserved Instance may meet your needs\. For more information, see [Scheduled Reserved Instances](ec2-scheduled-instances.md)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/reserved-instances-types.md |
ea8ddb855911-0 | You can exchange one or more Convertible Reserved Instances for another Convertible Reserved Instance with a different configuration, including instance family, operating system, and tenancy\. There are no limits to how many times you perform an exchange, as long as the target Convertible Reserved Instance is of an equal or higher value than the Convertible Reserved Instances that you are exchanging\.
When you exchange your Convertible Reserved Instance, the number of instances for your current reservation is exchanged for a number of instances that cover the equal or higher value of the configuration of the target Convertible Reserved Instance\. Amazon EC2 calculates the number of Reserved Instances that you can receive as a result of the exchange\.
**Topics**
+ [Requirements for exchanging Convertible Reserved Instances](#riconvertible-exchange-limits)
+ [Calculating Convertible Reserved Instances exchanges](#riconvertible-exchange-cost)
+ [Merging Convertible Reserved Instances](#ri-merge-convertible)
+ [Exchanging a portion of a Convertible Reserved Instance](#ri-split-convertible)
+ [Submitting exchange requests](#ri-exchange-process) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ri-convertible-exchange.md |
540e8907b251-0 | If the following conditions are met, Amazon EC2 processes your exchange request\. Your Convertible Reserved Instance must be:
+ Active
+ Not pending a previous exchange request
The following rules apply:
+ Convertible Reserved Instances can only be exchanged for other Convertible Reserved Instances currently offered by AWS\.
+ Convertible Reserved Instances are associated with a specific Region, which is fixed for the duration of the reservation's term\. You cannot exchange a Convertible Reserved Instance for a Convertible Reserved Instance in a different Region\.
+ You can exchange one or more Convertible Reserved Instances at a time for one Convertible Reserved Instance only\.
+ To exchange a portion of a Convertible Reserved Instance, you can modify it into two or more reservations, and then exchange one or more of the reservations for a new Convertible Reserved Instance\. For more information, see [Exchanging a portion of a Convertible Reserved Instance](#ri-split-convertible)\. For more information about modifying your Reserved Instances, see [Modifying Reserved Instances](ri-modifying.md)\.
+ All Upfront Convertible Reserved Instances can be exchanged for Partial Upfront Convertible Reserved Instances, and vice versa\.
**Note**
If the total upfront payment required for the exchange \(true\-up cost\) is less than $0\.00, AWS automatically gives you a quantity of instances in the Convertible Reserved Instance that ensures that true\-up cost is $0\.00 or more\.
**Note** | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ri-convertible-exchange.md |
540e8907b251-1 | **Note**
If the total value \(upfront price \+ hourly price \* number of remaining hours\) of the new Convertible Reserved Instance is less than the total value of the exchanged Convertible Reserved Instance, AWS automatically gives you a quantity of instances in the Convertible Reserved Instance that ensures that the total value is the same or higher than that of the exchanged Convertible Reserved Instance\.
+ To benefit from better pricing, you can exchange a No Upfront Convertible Reserved Instance for an All Upfront or Partial Upfront Convertible Reserved Instance\.
+ You cannot exchange All Upfront and Partial Upfront Convertible Reserved Instances for No Upfront Convertible Reserved Instances\.
+ You can exchange a No Upfront Convertible Reserved Instance for another No Upfront Convertible Reserved Instance only if the new Convertible Reserved Instance's hourly price is the same or higher than the exchanged Convertible Reserved Instance's hourly price\.
**Note**
If the total value \(hourly price \* number of remaining hours\) of the new Convertible Reserved Instance is less than the total value of the exchanged Convertible Reserved Instance, AWS automatically gives you a quantity of instances in the Convertible Reserved Instance that ensures that the total value is the same or higher than that of the exchanged Convertible Reserved Instance\.
+ If you exchange multiple Convertible Reserved Instances that have different expiration dates, the expiration date for the new Convertible Reserved Instance is the date that's furthest in the future\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ri-convertible-exchange.md |
540e8907b251-2 | + If you exchange multiple Convertible Reserved Instances that have different expiration dates, the expiration date for the new Convertible Reserved Instance is the date that's furthest in the future\.
+ If you exchange a single Convertible Reserved Instance, it must have the same term \(1\-year or 3\-years\) as the new Convertible Reserved Instance\. If you merge multiple Convertible Reserved Instances with different term lengths, the new Convertible Reserved Instance has a 3\-year term\. For more information, see [Merging Convertible Reserved Instances](#ri-merge-convertible)\.
+ After you exchange a Convertible Reserved Instance, the original reservation is retired\. Its end date is the start date of the new reservation, and the end date of the new reservation is the same as the end date of the original Convertible Reserved Instance\. For example, if you modify a three\-year reservation that had 16 months left in its term, the resulting modified reservation is a 16\-month reservation with the same end date as the original one\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ri-convertible-exchange.md |
b42d52fec428-0 | Exchanging Convertible Reserved Instances is free\. However, you may be required to pay a true\-up cost, which is a prorated upfront cost of the difference between the Convertible Reserved Instances that you had and the Convertible Reserved Instances that you receive from the exchange\.
Each Convertible Reserved Instance has a list value\. This list value is compared to the list value of the Convertible Reserved Instances that you want in order to determine how many instance reservations you can receive from the exchange\.
For example: You have 1 x $35\-list value Convertible Reserved Instance that you want to exchange for a new instance type with a list value of $10\.
```
$35/$10 = 3.5
```
You can exchange your Convertible Reserved Instance for three $10 Convertible Reserved Instances\. It's not possible to purchase half reservations; therefore you must purchase an additional Convertible Reserved Instance to cover the remainder:
```
3.5 = 3 whole Convertible Reserved Instances + 1 additional Convertible Reserved Instance.
```
The fourth Convertible Reserved Instance has the same end date as the other three\. If you are exchanging Partial or All Upfront Convertible Reserved Instances, you pay the true\-up cost for the fourth reservation\. If the remaining upfront cost of your Convertible Reserved Instances is $500, and the target reservation would normally cost $600 on a prorated basis, you are charged $100\.
```
$600 prorated upfront cost of new reservations - $500 remaining upfront cost of original reservations = $100 difference.
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ri-convertible-exchange.md |
705745af9988-0 | If you merge two or more Convertible Reserved Instances, the term of the new Convertible Reserved Instance must be the same as the original Convertible Reserved Instances, or the highest of the original Convertible Reserved Instances\. The expiration date for the new Convertible Reserved Instance is the expiration date that's furthest in the future\.
For example, you have the following Convertible Reserved Instances in your account:
| Reserved Instance ID | Term | Expiration date |
| --- | --- | --- |
| aaaa1111 | 1\-year | 2018\-12\-31 |
| bbbb2222 | 1\-year | 2018\-07\-31 |
| cccc3333 | 3\-year | 2018\-06\-30 |
| dddd4444 | 3\-year | 2019\-12\-31 |
+ You can merge `aaaa1111` and `bbbb2222` and exchange them for a 1\-year Convertible Reserved Instance\. You cannot exchange them for a 3\-year Convertible Reserved Instance\. The expiration date of the new Convertible Reserved Instance is 2018\-12\-31\.
+ You can merge `bbbb2222` and `cccc3333` and exchange them for a 3\-year Convertible Reserved Instance\. You cannot exchange them for a 1\-year Convertible Reserved Instance\. The expiration date of the new Convertible Reserved Instance is 2018\-07\-31\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ri-convertible-exchange.md |
705745af9988-1 | + You can merge `cccc3333` and `dddd4444` and exchange them for a 3\-year Convertible Reserved Instance\. You cannot exchange them for a 1\-year Convertible Reserved Instance\. The expiration date of the new Convertible Reserved Instance is 2019\-12\-31\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ri-convertible-exchange.md |
ee168e6d8c7e-0 | You can use the modification process to split your Convertible Reserved Instance into smaller reservations, and then exchange one or more of the new reservations for a new Convertible Reserved Instance\. The following examples demonstrate how you can do this\.
**Example: Convertible Reserved Instance with multiple instances**
In this example, you have a `t2.micro` Convertible Reserved Instance with four instances in the reservation\. To exchange two `t2.micro` instances for an `m4.xlarge` instance:
1. Modify the `t2.micro` Convertible Reserved Instance by splitting it into two `t2.micro` Convertible Reserved Instances with two instances each\.
1. Exchange one of the new `t2.micro` Convertible Reserved Instances for an `m4.xlarge` Convertible Reserved Instance\.
![\[Modifying and exchange Reserved Instances\]](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/images/ri-split-cri-multiple.png)
**Example: Convertible Reserved Instance with a single instance**
In this example, you have a `t2.large` Convertible Reserved Instance\. To change it to a smaller `t2.medium` instance and a `m3.medium` instance:
1. Modify the `t2.large` Convertible Reserved Instance by splitting it into two `t2.medium` Convertible Reserved Instances\. A single `t2.large` instance has the same instance size footprint as two `t2.medium` instances\.
1. Exchange one of the new `t2.medium` Convertible Reserved Instances for an `m3.medium` Convertible Reserved Instance\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ri-convertible-exchange.md |
ee168e6d8c7e-1 | 1. Exchange one of the new `t2.medium` Convertible Reserved Instances for an `m3.medium` Convertible Reserved Instance\.
![\[Modify and exchange Reserved Instances\]](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/images/ri-split-cri-single.png)
For more information, see [Support for modifying instance sizes](ri-modifying.md#ri-modification-instancemove) and [Submitting exchange requests](#ri-exchange-process)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ri-convertible-exchange.md |
8af7038fdcda-0 | You can exchange your Convertible Reserved Instances using the Amazon EC2 console or a command line tool\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ri-convertible-exchange.md |
bc91d0a4bbc4-0 | You can search for Convertible Reserved Instances offerings and select your new configuration from the choices provided\.
**To exchange Convertible Reserved Instances using the Amazon EC2 console**
1. Open the Amazon EC2 console at [https://console\.aws\.amazon\.com/ec2/](https://console.aws.amazon.com/ec2/)\.
1. Choose **Reserved Instances**, select the Convertible Reserved Instances to exchange, and choose **Actions**, **Exchange Reserved Instance**\.
1. Select the attributes of the desired configuration using the drop\-down menus, and choose **Find Offering**\.
1. Select a new Convertible Reserved Instance The **Instance Count** column displays the number of Reserved Instances that you receive for the exchange\. When you have selected a Convertible Reserved Instance that meets your needs, choose **Exchange**\.
The Reserved Instances that were exchanged are retired, and the new Reserved Instances are displayed in the Amazon EC2 console\. This process can take a few minutes to propagate\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ri-convertible-exchange.md |
2f3530570b70-0 | To exchange a Convertible Reserved Instance, first find a target Convertible Reserved Instance that meets your needs:
+ [describe\-reserved\-instances\-offerings](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-reserved-instances-offerings.html) \(AWS CLI\)
+ [Get\-EC2ReservedInstancesOffering](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2ReservedInstancesOffering.html) \(Tools for Windows PowerShell\)
Get a quote for the exchange, which includes the number of Reserved Instances you get from the exchange, and the true\-up cost for the exchange:
+ [get\-reserved\-instances\-exchange\-quote](https://docs.aws.amazon.com/cli/latest/reference/ec2/get-reserved-instances-exchange-quote.html) \(AWS CLI\)
+ [GetEC2\-ReservedInstancesExchangeQuote](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2ReservedInstancesExchangeQuote.html) \(Tools for Windows PowerShell\)
Finally, perform the exchange:
+ [accept\-reserved\-instances\-exchange\-quote](https://docs.aws.amazon.com/cli/latest/reference/ec2/accept-reserved-instances-exchange-quote.html) \(AWS CLI\) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ri-convertible-exchange.md |
2f3530570b70-1 | + [Confirm\-EC2ReservedInstancesExchangeQuote](https://docs.aws.amazon.com/powershell/latest/reference/items/Confirm-EC2ReservedInstancesExchangeQuote.html) \(Tools for Windows PowerShell\) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ri-convertible-exchange.md |
475bfcb52b57-0 | Scaling based on a schedule enables you to scale your application in response to predictable changes in demand\. To use scheduled scaling, you create *scheduled actions*, which tell Spot Fleet to perform scaling activities at specific times\. When you create a scheduled action, you specify the Spot Fleet, when the scaling activity should occur, minimum capacity, and maximum capacity\. You can create scheduled actions that scale one time only or that scale on a recurring schedule\.
**Limits**
+ The Spot Fleet request must have a request type of `maintain`\. Automatic scaling is not supported for one\-time requests or Spot blocks\.
**To create a one\-time scheduled action**
1. Open the Amazon EC2 console at [https://console\.aws\.amazon\.com/ec2/](https://console.aws.amazon.com/ec2/)\.
1. In the navigation pane, choose **Spot Requests**\.
1. Select your Spot Fleet request and choose **Scheduled Scaling**\.
1. Choose **Create Scheduled Action**\.
1. For **Name**, specify a name for the scheduled action\.
1. Enter a value for **Minimum capacity**, **Maximum capacity**, or both\.
1. For **Recurrence**, choose **Once**\.
1. \(Optional\) Choose a date and time for **Start time**, **End time**, or both\.
1. Choose **Submit**\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/spot-fleet-scheduled-scaling.md |
475bfcb52b57-1 | 1. Choose **Submit**\.
**To scale on a recurring schedule**
1. Open the Amazon EC2 console at [https://console\.aws\.amazon\.com/ec2/](https://console.aws.amazon.com/ec2/)\.
1. In the navigation pane, choose **Spot Requests**\.
1. Select your Spot Fleet request and choose **Scheduled Scaling**\.
1. For **Recurrence**, choose one of the predefined schedules \(for example, **Every day**\), or choose **Custom** and type a cron expression\. For more information about the cron expressions supported by scheduled scaling, see [Cron Expressions](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html#CronExpressions) in the *Amazon CloudWatch Events User Guide*\.
1. \(Optional\) Choose a date and time for **Start time**, **End time**, or both\.
1. Choose **Submit**\.
**To edit a scheduled action**
1. Open the Amazon EC2 console at [https://console\.aws\.amazon\.com/ec2/](https://console.aws.amazon.com/ec2/)\.
1. In the navigation pane, choose **Spot Requests**\.
1. Select your Spot Fleet request and choose **Scheduled Scaling**\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/spot-fleet-scheduled-scaling.md |
475bfcb52b57-2 | 1. In the navigation pane, choose **Spot Requests**\.
1. Select your Spot Fleet request and choose **Scheduled Scaling**\.
1. Select the scheduled action and choose **Actions**, **Edit**\.
1. Make the needed changes and choose **Submit**\.
**To delete a scheduled action**
1. Open the Amazon EC2 console at [https://console\.aws\.amazon\.com/ec2/](https://console.aws.amazon.com/ec2/)\.
1. In the navigation pane, choose **Spot Requests**\.
1. Select your Spot Fleet request and choose **Scheduled Scaling**\.
1. Select the scheduled action and choose **Actions**, **Delete**\.
1. When prompted for confirmation, choose **Delete**\.
**To manage scheduled scaling using the AWS CLI**
Use the following commands:
+ [put\-scheduled\-action](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scheduled-action.html)
+ [describe\-scheduled\-actions](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scheduled-actions.html) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/spot-fleet-scheduled-scaling.md |
475bfcb52b57-3 | + [delete\-scheduled\-action](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/delete-scheduled-action.html) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/spot-fleet-scheduled-scaling.md |
5653e896d513-0 | **Warning**
Diagnostic interrupts are intended for use by advanced users\. Incorrect usage could negatively impact your instance\. Sending a diagnostic interrupt to an instance could trigger an instance to crash and reboot, which could lead to the loss of data\.
You can send a diagnostic interrupt to an unreachable or unresponsive Linux instance to manually trigger a *kernel panic*\.
Linux operating systems typically crash and reboot when a kernel panic occurs\. The specific behavior of the operating system depends on its configuration\. A kernel panic can also be used to cause the instance's operating system kernel to perform tasks, such as generating a crash dump file\. You can then use the information in the crash dump file to conduct root cause analysis and debug the instance\.
The crash dump data is generated locally by the operating system on the instance itself\.
Before sending a diagnostic interrupt to your instance, we recommend that you consult the documentation for your operating system and then make the necessary configuration changes\.
**Topics**
+ [Supported instance types](#diagnostic-interrupt-instances)
+ [Prerequisites](#diagnostic-interrupt-prereqs)
+ [Sending a diagnostic interrupt](#diagnostic-interrupt-use) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/diagnostic-interrupt.md |
66d284e310bb-0 | Diagnostic interrupt is supported on all Nitro\-based instance types, except A1\. For more information, see [Instances built on the Nitro System](instance-types.md#ec2-nitro-instances)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/diagnostic-interrupt.md |
79c45a70f124-0 | Before using a diagnostic interrupt, you must configure your instance's operating system\. This ensures that it performs the actions that you need when a kernel panic occurs\.
**To configure Amazon Linux 2 to generate a crash dump when a kernel panic occurs**
1. Connect to your instance\.
1. Install **kexec** and **kdump**\.
```
[ec2-user ~]$ sudo yum install kexec-tools -y
```
1. Configure the kernel to reserve an appropriate amount of memory for the secondary kernel\. The amount of memory to reserve depends on the total available memory of your instance\. Open the `/etc/default/grub` file using your preferred text editor, locate the line that starts with `GRUB_CMDLINE_LINUX_DEFAULT`, and then add the `crashkernel` parameter in the following format: `crashkernel=memory_to_reserve`\. For example, to reserve `160MB`, modify the `grub` file as follows:
```
GRUB_CMDLINE_LINUX_DEFAULT="crashkernel=160M console=tty0 console=ttyS0,115200n8 net.ifnames=0 biosdevname=0 nvme_core.io_timeout=4294967295 rd.emergency=poweroff rd.shell=0"
GRUB_TIMEOUT=0
GRUB_DISABLE_RECOVERY="true"
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/diagnostic-interrupt.md |
79c45a70f124-1 | GRUB_TIMEOUT=0
GRUB_DISABLE_RECOVERY="true"
```
1. Save the changes and close the `grub` file\.
1. Rebuild the GRUB2 configuration file\.
```
[ec2-user ~]$ sudo grub2-mkconfig -o /boot/grub2/grub.cfg
```
1. On instances based on Intel and AMD processors, the `send-diagnostic-interrupt` command sends an *unknown non\-maskable interrupt* \(NMI\) to the instance\. You must configure the kernel to crash when it receives the unknown NMI\. Open the `/etc/sysctl.conf` file using your preferred text editor and add the following\.
```
kernel.unknown_nmi_panic=1
```
1. Reboot and reconnect to your instance\.
1. Verify that the kernel has been booted with the correct `crashkernel` parameter\.
```
$ grep crashkernel /proc/cmdline
```
The following example output indicates successful configuration\.
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/diagnostic-interrupt.md |
79c45a70f124-2 | ```
The following example output indicates successful configuration\.
```
BOOT_IMAGE=/boot/vmlinuz-4.14.128-112.105.amzn2.x86_64 root=UUID=a1e1011e-e38f-408e-878b-fed395b47ad6 ro crashkernel=160M console=tty0 console=ttyS0,115200n8 net.ifnames=0 biosdevname=0 nvme_core.io_timeout=4294967295 rd.emergency=poweroff rd.shell=0
```
1. Verify that the **kdump** service is running\.
```
[ec2-user ~]$ systemctl status kdump.service
```
The following example output shows the result if the **kdump** service is running\.
```
kdump.service - Crash recovery kernel arming
Loaded: loaded (/usr/lib/systemd/system/kdump.service; enabled; vendor preset: enabled)
Active: active (exited) since Fri 2019-05-24 23:29:13 UTC; 22s ago
Process: 2503 ExecStart=/usr/bin/kdumpctl start (code=exited, status=0/SUCCESS)
Main PID: 2503 (code=exited, status=0/SUCCESS)
```
**Note** | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/diagnostic-interrupt.md |
79c45a70f124-3 | Main PID: 2503 (code=exited, status=0/SUCCESS)
```
**Note**
By default, the crash dump file is saved to `/var/crash/`\. To change the location, modify the `/etc/kdump.conf` file using your preferred text editor\.
**To configure Amazon Linux to generate a crash dump when a kernel panic occurs**
1. Connect to your instance\.
1. Install **kexec** and **kdump**\.
```
[ec2-user ~]$ sudo yum install kexec-tools -y
```
1. Configure the kernel to reserve an appropriate amount of memory for the secondary kernel\. The amount of memory to reserve depends on the total available memory of your instance\.
```
$ sudo grubby --args="crashkernel=memory_to_reserve" --update-kernel=ALL
```
For example, to reserve `160MB` for the crash kernel, use the following command\.
```
$ sudo grubby --args="crashkernel=160M" --update-kernel=ALL
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/diagnostic-interrupt.md |
79c45a70f124-4 | $ sudo grubby --args="crashkernel=160M" --update-kernel=ALL
```
1. On instances based on Intel and AMD processors, the `send-diagnostic-interrupt` command sends an *unknown non\-maskable interrupt* \(NMI\) to the instance\. You must configure the kernel to crash when it receives the unknown NMI\. Open the `/etc/sysctl.conf` file using your preferred text editor and add the following\.
```
kernel.unknown_nmi_panic=1
```
1. Reboot and reconnect to your instance\.
1. Verify that the kernel has been booted with the correct `crashkernel` parameter\.
```
$ grep crashkernel /proc/cmdline
```
The following example output indicates successful configuration\.
```
root=LABEL=/ console=tty1 console=ttyS0 selinux=0 nvme_core.io_timeout=4294967295 LANG=en_US.UTF-8 KEYTABLE=us crashkernel=160M
```
1. Verify that the **kdump** service is running\.
```
[ec2-user ~]$ sudo service kdump status
```
If the service is running, the command returns the `Kdump is operational` response\.
**Note** | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/diagnostic-interrupt.md |
79c45a70f124-5 | ```
If the service is running, the command returns the `Kdump is operational` response\.
**Note**
By default, the crash dump file is saved to `/var/crash/`\. To change the location, modify the `/etc/kdump.conf` file using your preferred text editor\.
**To configure SUSE Linux Enterprise, Ubuntu, or Red Hat Enterprise Linux**
See the following websites:
+ [SUSE Linux Enterprise](https://www.suse.com/support/kb/doc/?id=3374462)
+ [Ubuntu](https://ubuntu.com/server/docs/kernel-crash-dump)
+ [ Red Hat Enterprise Linux \(RHEL\)](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/7/html/kernel_administration_guide/kernel_crash_dump_guide)
**Note**
On instances based on Intel and AMD processors, the `send-diagnostic-interrupt` command sends an *unknown non\-maskable interrupt* \(NMI\) to the instance\. You must configure the kernel to crash when it receives the unknown NMI\. Add the following to your configuration file\.
```
kernel.unknown_nmi_panic=1
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/diagnostic-interrupt.md |
1fe052aba397-0 | After you have completed the necessary configuration changes, you can send a diagnostic interrupt to your instance using the AWS CLI or Amazon EC2 API\.
**To send a diagnostic interrupt to your instance \(AWS CLI\)**
Use the [send\-diagnostic\-interrupt](https://docs.aws.amazon.com/cli/latest/reference/ec2/send-diagnostic-interrupt.html) command and specify the instance ID\.
```
aws ec2 send-diagnostic-interrupt --instance-id i-1234567890abcdef0
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/diagnostic-interrupt.md |
bd75c16322d2-0 | To use EC2 Instance Connect to connect to an instance, you need to configure every instance that will support using Instance Connect \(this is a one\-time requirement for each instance\), and you need to grant permission to every IAM user that will use Instance Connect\.
**Topics**
+ [Task 1: Configure network access to an instance](#ec2-instance-connect-setup-security-group)
+ [Task 2: \(Conditional\) Install EC2 Instance Connect on an instance](#ec2-instance-connect-install)
+ [Task 3: \(Optional\) Install the EC2 Instance Connect CLI](#ec2-instance-connect-install-eic-CLI)
+ [Task 4: Configure IAM permissions for EC2 Instance Connect](#ec2-instance-connect-configure-IAM-role)
For more information about setting up EC2 Instance Connect, see [Securing your bastion hosts with Amazon EC2 Instance Connect](http://aws.amazon.com/blogs/infrastructure-and-automation/securing-your-bastion-hosts-with-amazon-ec2-instance-connect/)\.
**Limitations**
+ The following Linux distributions are supported:
+ Amazon Linux 2 \(any version\)
+ Ubuntu 16\.04 or later
+ If you configured the `AuthorizedKeysCommand` and `AuthorizedKeysCommandUser` settings for SSH authentication, the EC2 Instance Connect installation will not update them\. As a result, you cannot use Instance Connect\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-connect-set-up.md |
bd75c16322d2-1 | **Prerequisites**
+ **Verify the general prerequisites for connecting to your instance using SSH\.**
For more information, see [General prerequisites for connecting to your instance](connection-prereqs.md)\.
+ **Install an SSH client on your local computer\.**
Your local computer most likely has an SSH client installed by default\. You can check for an SSH client by typing ssh at the command line\. If your local computer doesn't recognize the command, you can install an SSH client\. For information about installing an SSH client on Linux or macOS X, see [http://www\.openssh\.com](http://www.openssh.com/)\. For information about installing an SSH client on Windows 10, see [OpenSSH in Windows](https://docs.microsoft.com/en-us/windows-server/administration/openssh/openssh_overview)\.
+ **Install the AWS CLI on your local computer\.**
To configure the IAM permissions, you must use the AWS CLI\. For more information about installing the AWS CLI, see [Installing the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html) in the *AWS Command Line Interface User Guide*\.
+ **\[Ubuntu\] Install the AWS CLI on your instance\.** | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-connect-set-up.md |
bd75c16322d2-2 | + **\[Ubuntu\] Install the AWS CLI on your instance\.**
To install EC2 Instance Connect on an Ubuntu instance, you must use the AWS CLI on the instance\. For more information about installing the AWS CLI, see [Installing the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html) in the *AWS Command Line Interface User Guide*\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-connect-set-up.md |
9448a63b5e95-0 | You must configure the following network access to your instance so that you can install EC2 Instance Connect and enable your users to connect to your instance:
+ Ensure that the security group associated with your instance [allows inbound SSH traffic](authorizing-access-to-an-instance.md#add-rule-authorize-access) on port 22 from your IP address\. The default security group for the VPC does not allow incoming SSH traffic by default\. The security group created by the launch wizard allows incoming SSH traffic by default\. For more information, see [Authorizing inbound traffic for your Linux instances](authorizing-access-to-an-instance.md)\.
+ \(Browser\-based client\) We recommend that your instance allows inbound SSH traffic from the [recommended IP block published for the service](https://ip-ranges.amazonaws.com/ip-ranges.json)\. Use the `EC2_INSTANCE_CONNECT` filter for the `service` parameter to get the IP address ranges in the EC2 Instance Connect subset\. For more information, see [AWS IP Address Ranges](https://docs.aws.amazon.com/general/latest/gr/aws-ip-ranges.html) in the *Amazon Web Services General Reference*\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-connect-set-up.md |
082a87e14e1d-0 | Amazon Linux 2 2\.0\.20190618 or later and Ubuntu 20\.04 or later are preconfigured with EC2 Instance Connect\. If you launched your instance using one of these AMIs, you can skip this task\. For other supported Linux distributions, you must install Instance Connect on every instance that will support connecting using Instance Connect\.
Installing Instance Connect configures the SSH daemon on the instance\. The procedure for installing Instance Connect is different for instances launched using Amazon Linux 2 and Ubuntu\.
------ | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-connect-set-up.md |
a2d631c8dc2f-0 | **To install EC2 Instance Connect on an instance launched with Amazon Linux 2**
1. Connect to your instance using SSH\.
Use the SSH key pair that was assigned to your instance when you launched it and the default user name of the AMI that you used to launch your instance\. For Amazon Linux 2, the default user name is `ec2-user`\.
For example, if your instance was launched using Amazon Linux 2, your instance's public DNS name is `ec2-a-b-c-d.us-west-2.compute.amazonaws.com`, and the key pair is `my_ec2_private_key.pem`, use the following command to SSH into your instance:
```
$ ssh -i my_ec2_private_key.pem [email protected]
```
For more information about connecting to your instance, see [Connecting to your Linux instance using SSH](AccessingInstancesLinux.md)\.
1. Install the EC2 Instance Connect package on your instance\.
For Amazon Linux 2, use the yum install command\.
```
[ec2-user ~]$ sudo yum install ec2-instance-connect
```
You should see four new files in the `/opt/aws/bin/` folder:
```
eic_curl_authorized_keys
eic_harvest_hostkeys | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-connect-set-up.md |
a2d631c8dc2f-1 | ```
eic_curl_authorized_keys
eic_harvest_hostkeys
eic_parse_authorized_keys
eic_run_authorized_keys
```
1. \(Optional\) Verify that Instance Connect was successfully installed on your instance\.
Use the sudo less command to check that the `/etc/ssh/sshd_config` file was correctly updated as follows:
```
[ec2-user ~]$ sudo less /etc/ssh/sshd_config
```
Instance Connect was successfully installed if the `AuthorizedKeysCommand` and `AuthorizedKeysCommandUser` lines in the `/etc/ssh/sshd_config` file contain the following values:
```
AuthorizedKeysCommand /opt/aws/bin/eic_run_authorized_keys %u %f
AuthorizedKeysCommandUser ec2-instance-connect
```
+ `AuthorizedKeysCommand` sets the `eic_run_authorized_keys` file to look up the keys from the instance metadata
+ `AuthorizedKeysCommandUser` sets the system user as `ec2-instance-connect`
**Note**
If you previously configured `AuthorizedKeysCommand` and `AuthorizedKeysCommandUser`, the Instance Connect installation will not change the values and you will not be able to use Instance Connect\.
------ | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-connect-set-up.md |
cda02724b9cb-0 | **To install EC2 Instance Connect on an instance launched with Ubuntu 16\.04 or later**
1. Connect to your instance using SSH\.
Use the SSH key pair that was assigned to your instance when you launched it and use the default user name of the AMI that you used to launch your instance\. For an Ubuntu AMI, the user name is `ubuntu`\.
If your instance was launched using Ubuntu, your instance's public DNS name is `ec2-a-b-c-d.us-west-2.compute.amazonaws.com`, and the key pair is `my_ec2_private_key.pem`, use the following command to SSH into your instance:
```
$ ssh -i my_ec2_private_key.pem [email protected]
```
For more information about connecting to your instance, see [Connecting to your Linux instance using SSH](AccessingInstancesLinux.md)\.
1. \(Optional\) Ensure your instance has the latest Ubuntu AMI\.
For Ubuntu, use the following commands to update all the packages on your instance\.
```
ubuntu:~$ sudo apt-get update
```
```
ubuntu:~$ sudo apt-get upgrade
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-connect-set-up.md |
cda02724b9cb-1 | ```
```
ubuntu:~$ sudo apt-get upgrade
```
1. Install the Instance Connect package on your instance\.
For Ubuntu, use the sudo apt\-get command to install the `.deb` package\.
```
ubuntu:~$ sudo apt-get install ec2-instance-connect
```
You should see four new files in the `/usr/share/ec2-instance-connect/` folder:
```
eic_curl_authorized_keys
eic_harvest_hostkeys
eic_parse_authorized_keys
eic_run_authorized_keys
```
1. \(Optional\) Verify that Instance Connect was successfully installed on your instance\.
Use the sudo less command to check that the `/lib/systemd/system/ssh.service.d/ec2-instance-connect.conf` was correctly updated as follows:
```
ubuntu:~$ sudo less /lib/systemd/system/ssh.service.d/ec2-instance-connect.conf
```
Instance Connect was successfully installed if the `AuthorizedKeysCommand` and `AuthorizedKeysCommandUser` lines in the `/lib/systemd/system/ssh.service.d/ec2-instance-connect.conf` file contain the following values: | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-connect-set-up.md |
cda02724b9cb-2 | ```
AuthorizedKeysCommand /usr/share/ec2-instance-connect/eic_run_authorized_keys %u %f
AuthorizedKeysCommandUser ec2-instance-connect
```
+ `AuthorizedKeysCommand` sets the `eic_run_authorized_keys` file to look up the keys from the instance metadata
+ `AuthorizedKeysCommandUser` sets the system user as `ec2-instance-connect`
**Note**
If you previously configured `AuthorizedKeysCommand` and `AuthorizedKeysCommandUser`, the Instance Connect installation will not change the values and you will not be able to use Instance Connect\.
------
For more information about the EC2 Instance Connect package, see [aws/aws\-ec2\-instance\-connect\-config ](https://github.com/aws/aws-ec2-instance-connect-config) on the GitHub website\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-connect-set-up.md |
7a08c4c1f6c7-0 | The EC2 Instance Connect CLI provides a similar interface to standard SSH calls, which includes querying EC2 instance information, generating and publishing ephemeral public keys, and establishing an SSH connection through a single command, `mssh instance_id`\.
**Note**
There is no need to install the EC2 Instance Connect CLI if users will only use the browser\-based client or an SSH client to connect to an instance\.
**To install the EC2 Instance Connect CLI package**
Use `[pip](https://docs.aws.amazon.com/cli/latest/userguide/install-linux.html#install-linux-pip)` to install the `ec2instanceconnectcli` package\. For more information, see [aws/aws\-ec2\-instance\-connect\-cli ](https://github.com/aws/aws-ec2-instance-connect-cli) on the GitHub website, and [https://pypi\.org/project/ec2instanceconnectcli/](https://pypi.org/project/ec2instanceconnectcli/) on the Python Package Index \(PyPI\) website\.
```
$ pip install ec2instanceconnectcli
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-connect-set-up.md |
2d4b20c7b21b-0 | For your IAM users to connect to an instance using EC2 Instance Connect, you must grant them permission to push the public key to the instance\. You grant them the permission by creating an IAM policy and attaching the policy to the IAM users that require the permission\. For more information, see [Actions, Resources, and Condition Keys for Amazon EC2 Instance Connect](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonec2instanceconnect.html) in the *IAM User Guide*\.
The following instructions explain how to create the policy and attach it using the AWS CLI\. For instructions that use the AWS Management Console, see [Creating IAM Policies \(Console\)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-start) and [Adding Permissions by Attaching Policies Directly to the User](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-directly-console) in the *IAM User Guide*\.
**To grant an IAM user permission for EC2 Instance Connect \(AWS CLI\)**
1. Create a JSON policy document that includes the following: | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-connect-set-up.md |
2d4b20c7b21b-1 | 1. Create a JSON policy document that includes the following:
+ The `ec2-instance-connect:SendSSHPublicKey` action\. This grants an IAM user permission to push the public key to an instance\. With `ec2-instance-connect:SendSSHPublicKey`, consider restricting access to specific EC2 instances\. Otherwise, all IAM users with this permission can connect to all EC2 instances\.
+ The `ec2:osuser` condition\. This specifies the name of the OS user that can push the public key to an instance\. Use the default user name for the AMI that you used to launch the instance\. The default user name for Amazon Linux 2 is `ec2-user`, and for Ubuntu it's `ubuntu`\.
+ The `ec2:DescribeInstances` action\. This is required when using the EC2 Instance Connect CLI because the wrapper calls this action\. IAM users might already have permission to call this action from another policy\.
The following is an example policy document\. You can omit the statement for the `ec2:DescribeInstances` action if your users will only use an SSH client to connect to your instances\. You can replace the specified instances in `Resource` with the wildcard `*` to grant users access to all EC2 instances using EC2 Instance Connect\.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2-instance-connect:SendSSHPublicKey", | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-connect-set-up.md |
2d4b20c7b21b-2 | {
"Effect": "Allow",
"Action": "ec2-instance-connect:SendSSHPublicKey",
"Resource": [
"arn:aws:ec2:region:account-id:instance/i-1234567890abcdef0",
"arn:aws:ec2:region:account-id:instance/i-0598c7d356eba48d7"
],
"Condition": {
"StringEquals": {
"ec2:osuser": "ami-username"
}
}
},
{
"Effect": "Allow",
"Action": "ec2:DescribeInstances",
"Resource": "*"
}
]
}
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-connect-set-up.md |
2d4b20c7b21b-3 | "Resource": "*"
}
]
}
```
The preceding policy allows access to specific instances, identified by their instance ID\. Alternatively, you can use resource tags to control access to an instance\. Attribute\-based access control is an authorization strategy that defines permissions based on tags that can be attached to users and AWS resources\. For example, the following policy allows an IAM user to access an instance only if that instance has a resource tag with key=`tag-key` and value=`tag-value`\. For more information about using tags to control access to your AWS resources, see [Controlling Access to AWS Resources](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html#access_tags_control-resources) in the *IAM User Guide*\.
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":"ec2-instance-connect:SendSSHPublicKey",
"Resource": "arn:aws:ec2:region:account-id:instance/*",
"Condition":{
"StringEquals":{
"aws:ResourceTag/tag-key":"tag-value"
}
}
},
{
"Effect": "Allow", | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-connect-set-up.md |
2d4b20c7b21b-4 | }
}
},
{
"Effect": "Allow",
"Action": "ec2:DescribeInstances",
"Resource": "*"
}
]
}
```
1. Use the [create\-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/create-policy.html) command to create a new managed policy, and specify the JSON document that you created to use as the content for the new policy\.
```
$ aws iam create-policy --policy-name my-policy --policy-document file://JSON-file-name
```
1. Use the [attach\-user\-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-user-policy.html) command to attach the managed policy to the specified IAM user\. For the `--user-name` parameter, specify the friendly name \(not the ARN\) of the IAM user\.
```
$ aws iam attach-user-policy --policy-arn arn:aws:iam::account-id:policy/my-policy --user-name IAM-friendly-name
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-connect-set-up.md |
fe74b9e11263-0 | *Automatic scaling* is the ability to increase or decrease the target capacity of your Spot Fleet automatically based on demand\. A Spot Fleet can either launch instances \(scale out\) or terminate instances \(scale in\), within the range that you choose, in response to one or more scaling policies\.
Spot Fleet supports the following types of automatic scaling:
+ [Target tracking scaling](spot-fleet-target-tracking.md) – Increase or decrease
the current capacity of the fleet based on a target value for a specific metric\. This is similar to the way that your thermostat maintains the temperature of your home—you select temperature and the thermostat does the rest\.
+ [Step scaling](spot-fleet-step-scaling.md) – Increase or decrease the current capacity of the fleet based on a set of scaling adjustments, known as step adjustments, that vary based on the size of the alarm breach\.
+ [Scheduled scaling](spot-fleet-scheduled-scaling.md) – Increase or decrease the current capacity of the fleet based on the date and time\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/spot-fleet-automatic-scaling.md |
fe74b9e11263-1 | + [Scheduled scaling](spot-fleet-scheduled-scaling.md) – Increase or decrease the current capacity of the fleet based on the date and time\.
If you are using [instance weighting](spot-fleet.md#spot-instance-weighting), keep in mind that Spot Fleet can exceed the target capacity as needed\. Fulfilled capacity can be a floating\-point number but target capacity must be an integer, so Spot Fleet rounds up to the next integer\. You must take these behaviors into account when you look at the outcome of a scaling policy when an alarm is triggered\. For example, suppose that the target capacity is 30, the fulfilled capacity is 30\.1, and the scaling policy subtracts 1\. When the alarm is triggered, the automatic scaling process subtracts 1 from 30\.1 to get 29\.1 and then rounds it up to 30, so no scaling action is taken\. As another example, suppose that you selected instance weights of 2, 4, and 8, and a target capacity of 10, but no weight 2 instances were available so Spot Fleet provisioned instances of weights 4 and 8 for a fulfilled capacity of 12\. If the scaling policy decreases target capacity by 20% and an alarm is triggered, the automatic scaling process subtracts 12\*0\.2 from 12 to get 9\.6 and then rounds it up to 10, so no scaling action is taken\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/spot-fleet-automatic-scaling.md |
fe74b9e11263-2 | The scaling policies that you create for Spot Fleet support a cooldown period\. This is the number of seconds after a scaling activity completes where previous trigger\-related scaling activities can influence future scaling events\. For scale\-out policies, while the cooldown period is in effect, the capacity that has been added by the previous scale\-out event that initiated the cooldown is calculated as part of the desired capacity for the next scale out\. The intention is to continuously \(but not excessively\) scale out\. For scale in policies, the cooldown period is used to block subsequent scale in requests until it has expired\. The intention is to scale in conservatively to protect your application's availability\. However, if another alarm triggers a scale\-out policy during the cooldown period after a scale\-in, automatic scaling scales out your scalable target immediately\.
We recommend that you scale based on instance metrics with a 1\-minute frequency because that ensures a faster response to utilization changes\. Scaling on metrics with a 5\-minute frequency can result in slower response time and scaling on stale metric data\. To send metric data for your instances to CloudWatch in 1\-minute periods, you must specifically enable detailed monitoring\. For more information, see [Enable or disable detailed monitoring for your instances](using-cloudwatch-new.md) and [Create a Spot Fleet request using defined parameters \(console\)](spot-fleet-requests.md#create-spot-fleet-advanced)\.
For more information about configuring scaling for Spot Fleet, see the following resources: | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/spot-fleet-automatic-scaling.md |
fe74b9e11263-3 | For more information about configuring scaling for Spot Fleet, see the following resources:
+ [application\-autoscaling](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling) section of the *AWS CLI Command Reference*
+ [Application Auto Scaling API Reference](https://docs.aws.amazon.com/autoscaling/application/APIReference/)
+ [Application Auto Scaling User Guide](https://docs.aws.amazon.com/autoscaling/application/userguide/) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/spot-fleet-automatic-scaling.md |
4c1e9a2fcd82-0 | Automatic scaling for Spot Fleet is made possible by a combination of the Amazon EC2, Amazon CloudWatch, and Application Auto Scaling APIs\. Spot Fleet requests are created with Amazon EC2, alarms are created with CloudWatch, and scaling policies are created with Application Auto Scaling\.
In addition to the [IAM permissions for Spot Fleet](spot-fleet-requests.md#spot-fleet-iam-users) and Amazon EC2, the IAM user that accesses fleet scaling settings must have the appropriate permissions for the services that support dynamic scaling\. IAM users must have permissions to use the actions shown in the following example policy\.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"application-autoscaling:*",
"ec2:DescribeSpotFleetRequests",
"ec2:ModifySpotFleetRequest",
"cloudwatch:DeleteAlarms",
"cloudwatch:DescribeAlarmHistory",
"cloudwatch:DescribeAlarms",
"cloudwatch:DescribeAlarmsForMetric",
"cloudwatch:GetMetricStatistics",
"cloudwatch:ListMetrics",
"cloudwatch:PutMetricAlarm",
"cloudwatch:DisableAlarmActions",
"cloudwatch:EnableAlarmActions",
"iam:CreateServiceLinkedRole", | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/spot-fleet-automatic-scaling.md |
4c1e9a2fcd82-1 | "cloudwatch:EnableAlarmActions",
"iam:CreateServiceLinkedRole",
"sns:CreateTopic",
"sns:Subscribe",
"sns:Get*",
"sns:List*"
],
"Resource": "*"
}
]
}
```
You can also create your own IAM policies that allow more fine\-grained permissions for calls to the Application Auto Scaling API\. For more information, see [Authentication and Access Control](https://docs.aws.amazon.com/autoscaling/application/userguide/auth-and-access-control.html) in the *Application Auto Scaling User Guide*\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/spot-fleet-automatic-scaling.md |
4c1e9a2fcd82-2 | The Application Auto Scaling service also needs permission to describe your Spot Fleet and CloudWatch alarms, and permissions to modify your Spot Fleet target capacity on your behalf\. If you enable automatic scaling for your Spot Fleet, it creates a service\-linked role named `AWSServiceRoleForApplicationAutoScaling_EC2SpotFleetRequest`\. This service\-linked role grants Application Auto Scaling permission to describe the alarms for your policies, to monitor the current capacity of the fleet, and to modify the capacity of the fleet\. The original managed Spot Fleet role for Application Auto Scaling was `aws-ec2-spot-fleet-autoscale-role`, but it is no longer required\. The service\-linked role is the default role for Application Auto Scaling\. For more information, see [Service\-Linked Roles](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html) in the *Application Auto Scaling User Guide*\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/spot-fleet-automatic-scaling.md |
16ce266dd7d7-0 | You can create an Amazon CloudWatch alarm that monitors an Amazon EC2 instance and automatically recovers the instance if it becomes impaired due to an underlying hardware failure or a problem that requires AWS involvement to repair\. Terminated instances cannot be recovered\. A recovered instance is identical to the original instance, including the instance ID, private IP addresses, Elastic IP addresses, and all instance metadata\. If the impaired instance is in a placement group, the recovered instance runs in the placement group\. For more information about using Amazon CloudWatch alarms to recover an instance, see [Adding recover actions to Amazon CloudWatch alarms](UsingAlarmActions.md#AddingRecoverActions)\. To troubleshoot issues with instance recovery failures, see [Troubleshooting instance recovery failures](#TroubleshootingInstanceRecovery)\.
When the `StatusCheckFailed_System` alarm is triggered, and the recover action is initiated, you will be notified by the Amazon SNS topic that you selected when you created the alarm and associated the recover action\. During instance recovery, the instance is migrated during an instance reboot, and any data that is in\-memory is lost\. When the process is complete, information is published to the SNS topic you've configured for the alarm\. Anyone who is subscribed to this SNS topic will receive an email notification that includes the status of the recovery attempt and any further instructions\. You will notice an instance reboot on the recovered instance\.
Examples of problems that cause system status checks to fail include:
+ Loss of network connectivity
+ Loss of system power
+ Software issues on the physical host
+ Hardware issues on the physical host that impact network reachability | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-recover.md |
16ce266dd7d7-1 | + Loss of system power
+ Software issues on the physical host
+ Hardware issues on the physical host that impact network reachability
If your instance has a public IPv4 address, it retains the public IPv4 address after recovery\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-recover.md |
Subsets and Splits