id
stringlengths 14
16
| text
stringlengths 1
2.43k
| source
stringlengths 99
229
|
|---|---|---|
4d8c4f14e5b3-1 | Consequently, when you create an SSD\-backed volume supporting 3,000 IOPS \(either by provisioning an `io1` or `io2` volume at 3,000 IOPS or by sizing a `gp2` volume at 1000 GiB\), and you attach it to an EBS\-optimized instance that can provide sufficient bandwidth, you can transfer up to 3,000 I/Os of data per second, with throughput determined by I/O size\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ebs-io-characteristics.md |
583e5e4345e6-0 | The volume queue length is the number of pending I/O requests for a device\. Latency is the true end\-to\-end client time of an I/O operation, in other words, the time elapsed between sending an I/O to EBS and receiving an acknowledgement from EBS that the I/O read or write is complete\. Queue length must be correctly calibrated with I/O size and latency to avoid creating bottlenecks either on the guest operating system or on the network link to EBS\.
Optimal queue length varies for each workload, depending on your particular application's sensitivity to IOPS and latency\. If your workload is not delivering enough I/O requests to fully use the performance available to your EBS volume, then your volume might not deliver the IOPS or throughput that you have provisioned\.
Transaction\-intensive applications are sensitive to increased I/O latency and are well\-suited for SSD\-backed `io1`, `io2`, and `gp2` volumes\. You can maintain high IOPS while keeping latency down by maintaining a low queue length and a high number of IOPS available to the volume\. Consistently driving more IOPS to a volume than it has available can cause increased I/O latency\.
Throughput\-intensive applications are less sensitive to increased I/O latency, and are well\-suited for HDD\-backed `st1` and `sc1` volumes\. You can maintain high throughput to HDD\-backed volumes by maintaining a high queue length when performing large, sequential I/O\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ebs-io-characteristics.md |
403e2befe7d3-0 | For SSD\-backed volumes, if your I/O size is very large, you may experience a smaller number of IOPS than you provisioned because you are hitting the throughput limit of the volume\. For example, a `gp2` volume under 1000 GiB with burst credits available has an IOPS limit of 3,000 and a volume throughput limit of 250 MiB/s\. If you are using a 256 KiB I/O size, your volume reaches its throughput limit at 1000 IOPS \(1000 x 256 KiB = 250 MiB\)\. For smaller I/O sizes \(such as 16 KiB\), this same volume can sustain 3,000 IOPS because the throughput is well below 250 MiB/s\. \(These examples assume that your volume's I/O is not hitting the throughput limits of the instance\.\) For more information about the throughput limits for each EBS volume type, see [Amazon EBS volume types](ebs-volume-types.md)\.
For smaller I/O operations, you may see a higher\-than\-provisioned IOPS value as measured from inside your instance\. This happens when the instance operating system merges small I/O operations into a larger operation before passing them to Amazon EBS\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ebs-io-characteristics.md |
403e2befe7d3-1 | If your workload uses sequential I/Os on HDD\-backed `st1` and `sc1` volumes, you may experience a higher than expected number of IOPS as measured from inside your instance\. This happens when the instance operating system merges sequential I/Os and counts them in 1,024 KiB\-sized units\. If your workload uses small or random I/Os, you may experience a lower throughput than you expect\. This is because we count each random, non\-sequential I/O toward the total IOPS count, which can cause you to hit the volume's IOPS limit sooner than expected\.
Whatever your EBS volume type, if you are not experiencing the IOPS or throughput you expect in your configuration, ensure that your EC2 instance bandwidth is not the limiting factor\. You should always use a current\-generation, EBS\-optimized instance \(or one that includes 10 Gb/s network connectivity\) for optimal performance\. For more information, see [Amazon EBS–optimized instances](ebs-optimized.md)\. Another possible cause for not experiencing the expected IOPS is that you are not driving enough I/O to the EBS volumes\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ebs-io-characteristics.md |
4425a15d005b-0 | You can monitor these I/O characteristics with each volume's [CloudWatch volume metrics](using_cloudwatch_ebs.md#ebs-volume-metrics)\. Important metrics to consider include the following:
+ `BurstBalance`
+ `VolumeReadBytes`
+ `VolumeWriteBytes`
+ `VolumeReadOps`
+ `VolumeWriteOps`
+ `VolumeQueueLength`
`BurstBalance` displays the burst bucket balance for `gp2`, `st1`, and `sc1` volumes as a percentage of the remaining balance\. When your burst bucket is depleted, volume I/O \(for `gp2` volumes\) or volume throughput \(for `st1` and `sc1` volumes\) is throttled to the baseline\. Check the `BurstBalance` value to determine whether your volume is being throttled for this reason\.
HDD\-backed `st1` and `sc1` volumes are designed to perform best with workloads that take advantage of the 1,024 KiB maximum I/O size\. To determine your volume's average I/O size, divide `VolumeWriteBytes `by `VolumeWriteOps`\. The same calculation applies to read operations\. If average I/O size is below 64 KiB, increasing the size of the I/O operations sent to an `st1` or `sc1` volume should improve performance\.
**Note** | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ebs-io-characteristics.md |
4425a15d005b-1 | **Note**
If average I/O size is at or near 44 KiB, you might be using an instance or kernel without support for indirect descriptors\. Any Linux kernel 3\.8 and above has this support, as well as any current\-generation instance\.
If your I/O latency is higher than you require, check `VolumeQueueLength` to make sure your application is not trying to drive more IOPS than you have provisioned\. If your application requires a greater number of IOPS than your volume can provide, you should consider using a larger `gp2` volume with a higher base performance level or an `io1` or `io2` volume with more provisioned IOPS to achieve faster latencies\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ebs-io-characteristics.md |
73fa4673df5f-0 | For more information about Amazon EBS I/O characteristics, see the following re:Invent presentation: [Amazon EBS: Designing for Performance](https://www.youtube.com/watch?v=2wKgha8CZ_w)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ebs-io-characteristics.md |
e9cfb65407da-0 | You can share an AMI with specific AWS accounts without making the AMI public\. All you need is the AWS account IDs\. You can only share AMIs that have unencrypted volumes and volumes that are encrypted with a customer managed CMK\. If you share an AMI with encrypted volumes, you must also share any CMKs used to encrypt them\. For more information, see [Sharing an Amazon EBS snapshot](ebs-modifying-snapshot-permissions.md)\. You cannot share an AMI that has volumes that are encrypted with a AWS managed CMK\.
AMIs are a regional resource\. Therefore, sharing an AMI makes it available in that Region\. To make an AMI available in a different Region, copy the AMI to the Region and then share it\. For more information, see [Copying an AMI](CopyingAMIs.md)\.
There is no limit to the number of AWS accounts with which an AMI can be shared\. User\-defined tags that you attach to a shared AMI are available only to your AWS account and not to the other accounts that the AMI is shared with\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/sharingamis-explicit.md |
03b590fabbf7-0 | **To grant explicit launch permissions using the console**
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 **AMIs**\.
1. Select your AMI in the list, and then choose **Actions**, **Modify Image Permissions**\.
1. Specify the AWS account number of the user with whom you want to share the AMI in the **AWS Account Number** field, then choose **Add Permission**\.
To share this AMI with multiple users, repeat this step until you have added all the required users\.
1. To allow create volume permissions for snapshots, select ** Add "create volume" permissions to the following associated snapshots when creating permissions\.**
**Note**
You do not need to share the Amazon EBS snapshots that an AMI references in order to share the AMI\. Only the AMI itself needs to be shared; the system automatically provides the instance access to the referenced Amazon EBS snapshots for the launch\. However, you do need to share any CMKs used to encrypt snapshots that the AMI references\. For more information, see [Sharing an Amazon EBS snapshot](ebs-modifying-snapshot-permissions.md)\.
1. Choose **Save** when you are done\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/sharingamis-explicit.md |
03b590fabbf7-1 | 1. Choose **Save** when you are done\.
1. \(Optional\) To view the AWS account IDs with which you have shared the AMI, select the AMI in the list, and choose the **Permissions** tab\. To find AMIs that are shared with you, see [Finding shared AMIs](usingsharedamis-finding.md)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/sharingamis-explicit.md |
2d0d325cb6a0-0 | Use the [modify\-image\-attribute](https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-image-attribute.html) command \(AWS CLI\) to share an AMI as shown in the following examples\.
**To grant explicit launch permissions**
The following command grants launch permissions for the specified AMI to the specified AWS account\.
```
aws ec2 modify-image-attribute \
--image-id ami-0abcdef1234567890 \
--launch-permission "Add=[{UserId=123456789012}]"
```
The following command grants create volume permission for a snapshot\.
```
aws ec2 modify-snapshot-attribute \
--snapshot-id snap-1234567890abcdef0 \
--attribute createVolumePermission \
--operation-type add \
--user-ids 123456789012
```
**Note** | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/sharingamis-explicit.md |
2d0d325cb6a0-1 | --user-ids 123456789012
```
**Note**
You do not need to share the Amazon EBS snapshots that an AMI references in order to share the AMI\. Only the AMI itself needs to be shared; the system automatically provides the instance access to the referenced Amazon EBS snapshots for the launch\. However, you do need to share any CMKs used to encrypt snapshots that the AMI references\. For more information, see [Sharing an Amazon EBS snapshot](ebs-modifying-snapshot-permissions.md)\.
**To remove launch permissions for an account**
The following command removes launch permissions for the specified AMI from the specified AWS account:
```
aws ec2 modify-image-attribute \
--image-id ami-0abcdef1234567890 \
--launch-permission "Remove=[{UserId=123456789012}]"
```
The following command removes create volume permission for a snapshot\.
```
aws ec2 modify-snapshot-attribute \
--snapshot-id snap-1234567890abcdef0 \
--attribute createVolumePermission \
--operation-type remove \
--user-ids 123456789012
```
**To remove all launch permissions** | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/sharingamis-explicit.md |
2d0d325cb6a0-2 | --user-ids 123456789012
```
**To remove all launch permissions**
The following command removes all public and explicit launch permissions from the specified AMI\. Note that the owner of the AMI always has launch permissions and is therefore unaffected by this command\.
```
aws ec2 reset-image-attribute \
--image-id ami-0abcdef1234567890 \
--attribute launchPermission
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/sharingamis-explicit.md |
4064cd31fc55-0 | The following procedures help you install an Apache web server with PHP and [MariaDB](https://mariadb.org/about/) \(a community\-developed fork of MySQL\) support on your Amazon Linux 2 instance \(sometimes called a LAMP web server or LAMP stack\)\. You can use this server to host a static website or deploy a dynamic PHP application that reads and writes information to a database\.
**Important**
To set up a LAMP web server on Amazon Linux AMI, see [Tutorial: Install a LAMP web server with the Amazon Linux AMI](install-LAMP.md)\.
If you are trying to set up a LAMP web server on an Ubuntu or Red Hat Enterprise Linux instance, this tutorial will not work for you\. For more information about other distributions, see their specific documentation\. For information about LAMP web servers on Ubuntu, see the Ubuntu community documentation [ApacheMySQLPHP](https://help.ubuntu.com/community/ApacheMySQLPHP) topic\.
**Option: Complete this tutorial using automation**
To complete this tutorial using AWS Systems Manager Automation instead of the following tasks, run the [AWSDocs\-InstallALAMPServer\-AL2](https://console.aws.amazon.com/systems-manager/automation/execute/AWSDocs-InstallALAMPServer-AL2) Automation document\.
**Topics**
+ [Step 1: Prepare the LAMP server](#prepare-lamp-server)
+ [Step 2: Test your LAMP server](#test-lamp-server) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-lamp-amazon-linux-2.md |
4064cd31fc55-1 | + [Step 2: Test your LAMP server](#test-lamp-server)
+ [Step 3: Secure the database server](#secure-mariadb-lamp-server)
+ [Step 4: \(Optional\) Install phpMyAdmin](#install-phpmyadmin-lamp-server)
+ [Troubleshooting](#lamp-troubleshooting)
+ [Related topics](#lamp-more-info) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-lamp-amazon-linux-2.md |
5f779507a3c9-0 | **Prerequisites**
This tutorial assumes that you have already launched a new instance using Amazon Linux 2, with a public DNS name that is reachable from the internet\. For more information, see [Step 1: Launch an instance](EC2_GetStarted.md#ec2-launch-instance)\. You must also have configured your security group to allow SSH \(port 22\), HTTP \(port 80\), and HTTPS \(port 443\) connections\. For more information about these prerequisites, see [Authorizing inbound traffic for your Linux instances](authorizing-access-to-an-instance.md)\.
**Note**
The following procedure installs the latest PHP version available on Amazon Linux 2, currently PHP 7\.2\. If you plan to use PHP applications other than those described in this tutorial, you should check their compatibility with PHP 7\.2\.<a name="install_apache-2"></a>
**To prepare the LAMP server**
1. [Connect to your instance](EC2_GetStarted.md#ec2-connect-to-instance-linux)\.
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 that you have the latest security updates and bug fixes\.
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\.
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-lamp-amazon-linux-2.md |
5f779507a3c9-1 | ```
[ec2-user ~]$ sudo yum update -y
```
1. Install the `lamp-mariadb10.2-php7.2` and `php7.2` Amazon Linux Extras repositories to get the latest versions of the LAMP MariaDB and PHP packages for Amazon Linux 2\.
```
[ec2-user ~]$ sudo amazon-linux-extras install -y lamp-mariadb10.2-php7.2 php7.2
```
**Note**
If you receive an error stating `sudo: amazon-linux-extras: command not found`, then your instance was not launched with an Amazon Linux 2 AMI \(perhaps you are using the Amazon Linux AMI instead\)\. You can view your version of Amazon Linux with the following command\.
```
cat /etc/system-release
```
To set up a LAMP web server on Amazon Linux AMI , see [Tutorial: Install a LAMP web server with the Amazon Linux AMI](install-LAMP.md)\.
1. Now that your instance is current, you can install the Apache web server, MariaDB, and PHP software packages\.
Use the yum install command to install multiple software packages and all related dependencies at the same time\.
```
[ec2-user ~]$ sudo yum install -y httpd mariadb-server
```
**Note** | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-lamp-amazon-linux-2.md |
5f779507a3c9-2 | [ec2-user ~]$ sudo yum install -y httpd mariadb-server
```
**Note**
You can view the current versions of these packages with the following command:
```
yum info package_name
```
1. Start the Apache web server\.
```
[ec2-user ~]$ sudo systemctl start httpd
```
1. Use the systemctl command to configure the Apache web server to start at each system boot\.
```
[ec2-user ~]$ sudo systemctl enable httpd
```
You can verify that httpd is on by running the following command:
```
[ec2-user ~]$ sudo systemctl is-enabled httpd
```
1. Add a security rule to allow inbound HTTP \(port 80\) connections to your instance if you have not already done so\. By default, a **launch\-wizard\-*N*** security group was set up for your instance during initialization\. This group contains a single rule to allow SSH connections\.
1. Open the Amazon EC2 console at [https://console\.aws\.amazon\.com/ec2/](https://console.aws.amazon.com/ec2/)\.
1. Choose **Instances** and select your instance\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-lamp-amazon-linux-2.md |
5f779507a3c9-3 | 1. Choose **Instances** and select your instance\.
1. Under **Security groups**, choose **view inbound rules**\.
1. You should see the following list of rules in your default security group:
```
Security Groups associated with i-1234567890abcdef0
Ports Protocol Source launch-wizard-N
22 tcp 0.0.0.0/0 ✔
```
Using the procedures in [Adding rules to a security group](working-with-security-groups.md#adding-security-group-rule), add a new inbound security rule with the following values:
+ **Type**: HTTP
+ **Protocol**: TCP
+ **Port Range**: 80
+ **Source**: Custom
1. Test your web server\. In a web browser, type the public DNS address \(or the public IP address\) of your instance\. If there is no content in `/var/www/html`, you should see the Apache test page\. You can get the public DNS for your instance using the Amazon EC2 console \(check the **Public DNS** column; if this column is hidden, choose **Show/Hide Columns** \(the gear\-shaped icon\) and choose **Public DNS**\)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-lamp-amazon-linux-2.md |
5f779507a3c9-4 | If you are unable to see the Apache test page, check that the security group you are using contains a rule to allow HTTP \(port 80\) traffic\. For information about adding an HTTP rule to your security group, see [Adding rules to a security group](working-with-security-groups.md#adding-security-group-rule)\.
**Important**
If you are not using Amazon Linux, you may also need to configure the firewall on your instance to allow these connections\. For more information about how to configure the firewall, see the documentation for your specific distribution\.
![\[Apache test page\]](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/images/apache_test_page_al2_2.4.png)
Apache httpd serves files that are kept in a directory called the Apache document root\. The Amazon Linux Apache document root is `/var/www/html`, which by default is owned by root\.
To allow the `ec2-user` account to manipulate files in this directory, you must modify the ownership and permissions of the directory\. There are many ways to accomplish this task\. In this tutorial, you add `ec2-user` to the `apache` group, to give the `apache` group ownership of the `/var/www` directory and assign write permissions to the group\.<a name="setting-file-permissions-2"></a>
**To set file permissions** | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-lamp-amazon-linux-2.md |
5f779507a3c9-5 | **To set file permissions**
1. Add your user \(in this case, `ec2-user`\) to the `apache` group\.
```
[ec2-user ~]$ sudo usermod -a -G apache ec2-user
```
1. Log out and then log back in again to pick up the new group, and then verify your membership\.
1. Log out \(use the exit command or close the terminal window\):
```
[ec2-user ~]$ exit
```
1. To verify your membership in the `apache` group, reconnect to your instance, and then run the following command:
```
[ec2-user ~]$ groups
ec2-user adm wheel apache systemd-journal
```
1. Change the group ownership of `/var/www` and its contents to the `apache` group\.
```
[ec2-user ~]$ sudo chown -R ec2-user:apache /var/www
```
1. To add group write permissions and to set the group ID on future subdirectories, change the directory permissions of `/var/www` and its subdirectories\.
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-lamp-amazon-linux-2.md |
5f779507a3c9-6 | ```
[ec2-user ~]$ sudo chmod 2775 /var/www && find /var/www -type d -exec sudo chmod 2775 {} \;
```
1. To add group write permissions, recursively change the file permissions of `/var/www` and its subdirectories:
```
[ec2-user ~]$ find /var/www -type f -exec sudo chmod 0664 {} \;
```
Now, `ec2-user` \(and any future members of the `apache` group\) can add, delete, and edit files in the Apache document root, enabling you to add content, such as a static website or a PHP application\.
**To secure your web server \(Optional\)**
A web server running the HTTP protocol provides no transport security for the data that it sends or receives\. When you connect to an HTTP server using a web browser, the URLs that you visit, the content of webpages that you receive, and the contents \(including passwords\) of any HTML forms that you submit are all visible to eavesdroppers anywhere along the network pathway\. The best practice for securing your web server is to install support for HTTPS \(HTTP Secure\), which protects your data with SSL/TLS encryption\.
For information about enabling HTTPS on your server, see [Tutorial: Configure SSL/TLS on Amazon Linux 2](SSL-on-amazon-linux-2.md)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-lamp-amazon-linux-2.md |
5ba1ad489155-0 | If your server is installed and running, and your file permissions are set correctly, your `ec2-user` account should be able to create a PHP file in the `/var/www/html` directory that is available from the internet\.
**To test your LAMP server**
1. Create a PHP file in the Apache document root\.
```
[ec2-user ~]$ echo "<?php phpinfo(); ?>" > /var/www/html/phpinfo.php
```
If you get a "Permission denied" error when trying to run this command, try logging out and logging back in again to pick up the proper group permissions that you configured in [To set file permissions](#setting-file-permissions-2)\.
1. In a web browser, type the URL of the file that you just created\. This URL is the public DNS address of your instance followed by a forward slash and the file name\. For example:
```
http://my.public.dns.amazonaws.com/phpinfo.php
```
You should see the PHP information page:
![\[Image NOT FOUND\]](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/images/phpinfo7.2.10.png)
**Note** | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-lamp-amazon-linux-2.md |
5ba1ad489155-1 | **Note**
If you do not see this page, verify that the `/var/www/html/phpinfo.php` file was created properly in the previous step\. You can also verify that all of the required packages were installed with the following command\.
```
[ec2-user ~]$ sudo yum list installed httpd mariadb-server php-mysqlnd
```
If any of the required packages are not listed in your output, install them with the sudo yum install *package* command\. Also verify that the `php7.2` and `lamp-mariadb10.2-php7.2` extras are enabled in the output of the amazon\-linux\-extras command\.
1. Delete the `phpinfo.php` file\. Although this can be useful information, it should not be broadcast to the internet for security reasons\.
```
[ec2-user ~]$ rm /var/www/html/phpinfo.php
```
You should now have a fully functional LAMP web server\. If you add content to the Apache document root at `/var/www/html`, you should be able to view that content at the public DNS address for your instance\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-lamp-amazon-linux-2.md |
f74daddca51c-0 | The default installation of the MariaDB server has several features that are great for testing and development, but they should be disabled or removed for production servers\. The mysql\_secure\_installation command walks you through the process of setting a root password and removing the insecure features from your installation\. Even if you are not planning on using the MariaDB server, we recommend performing this procedure\.<a name="securing-maria-db"></a>
**To secure the MariaDB server**
1. Start the MariaDB server\.
```
[ec2-user ~]$ sudo systemctl start mariadb
```
1. Run mysql\_secure\_installation\.
```
[ec2-user ~]$ sudo mysql_secure_installation
```
1. When prompted, type a password for the root account\.
1. Type the current root password\. By default, the root account does not have a password set\. Press Enter\.
1. Type **Y** to set a password, and type a secure password twice\. For more information about creating a secure password, see [https://identitysafe\.norton\.com/password\-generator/](https://identitysafe.norton.com/password-generator/)\. Make sure to store this password in a safe place\.
**Note** | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-lamp-amazon-linux-2.md |
f74daddca51c-1 | **Note**
Setting a root password for MariaDB is only the most basic measure for securing your database\. When you build or install a database\-driven application, you typically create a database service user for that application and avoid using the root account for anything but database administration\.
1. Type **Y** to remove the anonymous user accounts\.
1. Type **Y** to disable the remote root login\.
1. Type **Y** to remove the test database\.
1. Type **Y** to reload the privilege tables and save your changes\.
1. \(Optional\) If you do not plan to use the MariaDB server right away, stop it\. You can restart it when you need it again\.
```
[ec2-user ~]$ sudo systemctl stop mariadb
```
1. \(Optional\) If you want the MariaDB server to start at every boot, type the following command\.
```
[ec2-user ~]$ sudo systemctl enable mariadb
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-lamp-amazon-linux-2.md |
d1577fd6f504-0 | [phpMyAdmin](https://www.phpmyadmin.net/) is a web\-based database management tool that you can use to view and edit the MySQL databases on your EC2 instance\. Follow the steps below to install and configure `phpMyAdmin` on your Amazon Linux instance\.
**Important**
We do not recommend using `phpMyAdmin` to access a LAMP server unless you have enabled SSL/TLS in Apache; otherwise, your database administrator password and other data are transmitted insecurely across the internet\. For security recommendations from the developers, see [Securing your phpMyAdmin installation](https://docs.phpmyadmin.net/en/latest/setup.html#securing-your-phpmyadmin-installation)\. For general information about securing a web server on an EC2 instance, see [Tutorial: Configure SSL/TLS on Amazon Linux 2](SSL-on-amazon-linux-2.md)\.
**To install phpMyAdmin**
1. Install the required dependencies\.
```
[ec2-user ~]$ sudo yum install php-mbstring -y
```
1. Restart Apache\.
```
[ec2-user ~]$ sudo systemctl restart httpd
```
1. Restart `php-fpm`\.
```
[ec2-user ~]$ sudo systemctl restart php-fpm
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-lamp-amazon-linux-2.md |
d1577fd6f504-1 | ```
[ec2-user ~]$ sudo systemctl restart php-fpm
```
1. Navigate to the Apache document root at `/var/www/html`\.
```
[ec2-user ~]$ cd /var/www/html
```
1. Select a source package for the latest phpMyAdmin release from [https://www\.phpmyadmin\.net/downloads](https://www.phpmyadmin.net/downloads)\. To download the file directly to your instance, copy the link and paste it into a wget command, as in this example:
```
[ec2-user html]$ wget https://www.phpmyadmin.net/downloads/phpMyAdmin-latest-all-languages.tar.gz
```
1. Create a `phpMyAdmin` folder and extract the package into it with the following command\.
```
[ec2-user html]$ mkdir phpMyAdmin && tar -xvzf phpMyAdmin-latest-all-languages.tar.gz -C phpMyAdmin --strip-components 1
```
1. Delete the *phpMyAdmin\-latest\-all\-languages\.tar\.gz* tarball\.
```
[ec2-user html]$ rm phpMyAdmin-latest-all-languages.tar.gz
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-lamp-amazon-linux-2.md |
d1577fd6f504-2 | ```
[ec2-user html]$ rm phpMyAdmin-latest-all-languages.tar.gz
```
1. \(Optional\) If the MySQL server is not running, start it now\.
```
[ec2-user ~]$ sudo systemctl start mariadb
```
1. In a web browser, type the URL of your phpMyAdmin installation\. This URL is the public DNS address \(or the public IP address\) of your instance followed by a forward slash and the name of your installation directory\. For example:
```
http://my.public.dns.amazonaws.com/phpMyAdmin
```
You should see the phpMyAdmin login page:
![\[Image NOT FOUND\]](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/images/phpmyadmin_login.png)
1. Log in to your phpMyAdmin installation with the `root` user name and the MySQL root password you created earlier\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-lamp-amazon-linux-2.md |
d1577fd6f504-3 | 1. Log in to your phpMyAdmin installation with the `root` user name and the MySQL root password you created earlier\.
Your installation must still be configured before you put it into service\. To configure phpMyAdmin, you can [manually create a configuration file](https://docs.phpmyadmin.net/en/latest/setup.html#manually-creating-the-file), [use the setup console](https://docs.phpmyadmin.net/en/latest/setup.html#using-setup-script), or combine both approaches\.
For information about using phpMyAdmin, see the [phpMyAdmin User Guide](http://docs.phpmyadmin.net/en/latest/user.html)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-lamp-amazon-linux-2.md |
55b74c788cf8-0 | This section offers suggestions for resolving common problems you may encounter while setting up a new LAMP server\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-lamp-amazon-linux-2.md |
83c61eb45690-0 | Perform the following checks to see if your Apache web server is running and accessible\.
+ **Is the web server running?**
You can verify that httpd is on by running the following command:
```
[ec2-user ~]$ sudo systemctl is-enabled httpd
```
If the httpd process is not running, repeat the steps described in [To prepare the LAMP server](#install_apache-2)\.
+ **Is the firewall correctly configured?**
If you are unable to see the Apache test page, check that the security group you are using contains a rule to allow HTTP \(port 80\) traffic\. For information about adding an HTTP rule to your security group, see [Adding rules to a security group](working-with-security-groups.md#adding-security-group-rule)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-lamp-amazon-linux-2.md |
d17f9c46f21b-0 | For more information about transferring files to your instance or installing a WordPress blog on your web server, see the following documentation:
+ [Transferring files to your Linux instance using WinSCP](putty.md#Transfer_WinSCP)
+ [Transferring files to Linux instances from Linux using SCP](AccessingInstancesLinux.md#AccessingInstancesLinuxSCP)
+ [Tutorial: Hosting a WordPress blog with Amazon Linux](hosting-wordpress.md)
For more information about the commands and software used in this tutorial, see the following webpages:
+ Apache web server: [http://httpd\.apache\.org/](http://httpd.apache.org/)
+ MariaDB database server: [https://mariadb\.org/](https://mariadb.org/)
+ PHP programming language: [http://php\.net/](http://php.net/)
+ The `chmod` command: [https://en\.wikipedia\.org/wiki/Chmod](https://en.wikipedia.org/wiki/Chmod)
+ The `chown` command: [https://en\.wikipedia\.org/wiki/Chown](https://en.wikipedia.org/wiki/Chown) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-lamp-amazon-linux-2.md |
d17f9c46f21b-1 | For more information about registering a domain name for your web server, or transferring an existing domain name to this host, see [Creating and Migrating Domains and Subdomains to Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/creating-migrating.html) in the *Amazon Route 53 Developer Guide*\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-lamp-amazon-linux-2.md |
b51f23c5dec3-0 | Use the following best practices for monitoring to help you with your Amazon EC2 monitoring tasks\.
+ Make monitoring a priority to head off small problems before they become big ones\.
+ Create and implement a monitoring plan that collects monitoring data from all of the parts in your AWS solution so that you can more easily debug a multi\-point failure if one occurs\. Your monitoring plan should address, at a minimum, the following questions:
+ What are your goals for monitoring?
+ What resources you will monitor?
+ How often you will monitor these resources?
+ What monitoring tools will you use?
+ Who will perform the monitoring tasks?
+ Who should be notified when something goes wrong?
+ Automate monitoring tasks as much as possible\.
+ Check the log files on your EC2 instances\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/monitoring_best_practices.md |
b1a42ac43d0e-0 | Compute optimized instances are ideal for compute\-bound applications that benefit from high\-performance processors\.
**C5 and C5n instances**
These instances are well suited for the following:
+ Batch processing workloads
+ Media transcoding
+ High\-performance web servers
+ High\-performance computing \(HPC\)
+ Scientific modeling
+ Dedicated gaming servers and ad serving engines
+ Machine learning inference and other compute\-intensive applications
Bare metal instances, such as `c5.metal`, provide your applications with direct access to physical resources of the host server, such as processors and memory\.
For more information, see [Amazon EC2 C5 Instances](https://aws.amazon.com/ec2/instance-types/c5)\.
**C6g and C6gd instances**
These instances are powered by AWS Graviton2 processors and are ideal for running advanced, compute\-intensive workloads, such as the following:
+ High\-performance computing \(HPC\)
+ Batch processing
+ Ad serving
+ Video encoding
+ Gaming servers
+ Scientific modeling
+ Distributed analytics
+ CPU\-based machine learning inference
Bare metal instances, such as `c6g.metal`, provide your applications with direct access to physical resources of the host server, such as processors and memory\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/compute-optimized-instances.md |
b1a42ac43d0e-1 | Bare metal instances, such as `c6g.metal`, provide your applications with direct access to physical resources of the host server, such as processors and memory\.
For more information, see [Amazon EC2 C6g Instances](https://aws.amazon.com/ec2/instance-types/c6)\.
**Topics**
+ [Hardware specifications](#compute-instances-hardware)
+ [Instance performance](#compute-performance)
+ [Network performance](#compute-network-performance)
+ [SSD I/O performance](#compute-ssd-perf)
+ [Instance features](#compute-instances-features)
+ [Release notes](#compute-instance-limits) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/compute-optimized-instances.md |
f27a95030011-0 | The following is a summary of the hardware specifications for compute optimized instances\.
| Instance type | Default vCPUs | Memory \(GiB\) |
| --- | --- | --- |
| c4\.large | 2 | 3\.75 |
| c4\.xlarge | 4 | 7\.5 |
| c4\.2xlarge | 8 | 15 |
| c4\.4xlarge | 16 | 30 |
| c4\.8xlarge | 36 | 60 |
| c5\.large | 2 | 4 |
| c5\.xlarge | 4 | 8 |
| c5\.2xlarge | 8 | 16 |
| c5\.4xlarge | 16 | 32 |
| c5\.9xlarge | 36 | 72 |
| c5\.12xlarge | 48 | 96 |
| c5\.18xlarge | 72 | 144 |
| c5\.24xlarge | 96 | 192 |
| c5\.metal | 96 | 192 |
| c5a\.large | 2 | 4 |
| c5a\.xlarge | 4 | 8 |
| c5a\.2xlarge | 8 | 16 |
| c5a\.4xlarge | 16 | 32 |
| c5a\.8xlarge | 32 | 64 | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/compute-optimized-instances.md |
f27a95030011-1 | | c5a\.4xlarge | 16 | 32 |
| c5a\.8xlarge | 32 | 64 |
| c5a\.12xlarge | 48 | 96 |
| c5a\.16xlarge | 64 | 128 |
| c5a\.24xlarge | 96 | 192 |
| c5ad\.large | 2 | 4 |
| c5ad\.xlarge | 4 | 8 |
| c5ad\.2xlarge | 8 | 16 |
| c5ad\.4xlarge | 16 | 32 |
| c5ad\.8xlarge | 32 | 64 |
| c5ad\.12xlarge | 48 | 96 |
| c5ad\.16xlarge | 64 | 128 |
| c5ad\.24xlarge | 96 | 192 |
| c5d\.large | 2 | 4 |
| c5d\.xlarge | 4 | 8 |
| c5d\.2xlarge | 8 | 16 |
| c5d\.4xlarge | 16 | 32 |
| c5d\.9xlarge | 36 | 72 |
| c5d\.12xlarge | 48 | 96 |
| c5d\.18xlarge | 72 | 144 |
| c5d\.24xlarge | 96 | 192 | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/compute-optimized-instances.md |
f27a95030011-2 | | c5d\.18xlarge | 72 | 144 |
| c5d\.24xlarge | 96 | 192 |
| c5d\.metal | 96 | 192 |
| c5n\.large | 2 | 5\.25 |
| c5n\.xlarge | 4 | 10\.5 |
| c5n\.2xlarge | 8 | 21 |
| c5n\.4xlarge | 16 | 42 |
| c5n\.9xlarge | 36 | 96 |
| c5n\.18xlarge | 72 | 192 |
| c5n\.metal | 72 | 192 |
| c6g\.medium | 1 | 2 |
| c6g\.large | 2 | 4 |
| c6g\.xlarge | 4 | 8 |
| c6g\.2xlarge | 8 | 16 |
| c6g\.4xlarge | 16 | 32 |
| c6g\.8xlarge | 32 | 64 |
| c6g\.12xlarge | 48 | 96 |
| c6g\.16xlarge | 64 | 128 |
| c6g\.metal | 64 | 128 |
| c6gd\.medium | 1 | 2 |
| c6gd\.large | 2 | 4 |
| c6gd\.xlarge | 4 | 8 | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/compute-optimized-instances.md |
f27a95030011-3 | | c6gd\.large | 2 | 4 |
| c6gd\.xlarge | 4 | 8 |
| c6gd\.2xlarge | 8 | 16 |
| c6gd\.4xlarge | 16 | 32 |
| c6gd\.8xlarge | 32 | 64 |
| c6gd\.12xlarge | 48 | 96 |
| c6gd\.16xlarge | 64 | 128 |
| c6gd\.metal | 64 | 128 |
For more information about the hardware specifications for each Amazon EC2 instance type, see [Amazon EC2 Instance Types](https://aws.amazon.com/ec2/instance-types/)\.
For more information about specifying CPU options, see [Optimizing CPU options](instance-optimize-cpu.md)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/compute-optimized-instances.md |
caa7223fa649-0 | EBS\-optimized instances enable you to get consistently high performance for your EBS volumes by eliminating contention between Amazon EBS I/O and other network traffic from your instance\. Some compute optimized instances are EBS\-optimized by default at no additional cost\. For more information, see [Amazon EBS–optimized instances](ebs-optimized.md)\.
Some compute optimized instance types provide the ability to control processor C\-states and P\-states on Linux\. C\-states control the sleep levels that a core can enter when it is inactive, while P\-states control the desired performance \(in CPU frequency\) from a core\. For more information, see [Processor state control for your EC2 instance](processor_state_control.md)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/compute-optimized-instances.md |
aee626b31575-0 | You can enable enhanced networking on supported instance types to provide lower latencies, lower network jitter, and higher packet\-per\-second \(PPS\) performance\. Most applications do not consistently need a high level of network performance, but can benefit from access to increased bandwidth when they send or receive data\. For more information, see [Enhanced networking on Linux](enhanced-networking.md)\.
The following is a summary of network performance for compute optimized instances that support enhanced networking\.
| Instance type | Network performance | Enhanced networking |
| --- | --- | --- |
| c5\.4xlarge and smaller \| c5d\.4xlarge and smaller \| c6g\.4xlarge and smaller \| c6gd\.4xlarge and smaller | Up to 10 Gbps † | [ENA](enhanced-networking-ena.md) |
| c5\.9xlarge \| c5d\.9xlarge | 10 Gbps | [ENA](enhanced-networking-ena.md) |
| c5\.12xlarge \| c5d\.12xlarge \| c6g\.8xlarge \| c6gd\.8xlarge | 12 Gbps | [ENA](enhanced-networking-ena.md) |
| c6g\.12xlarge \| c6gd\.12xlarge | 20 Gbps | [ENA](enhanced-networking-ena.md) | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/compute-optimized-instances.md |
aee626b31575-1 | | c5n\.4xlarge and smaller | Up to 25 Gbps † | [ENA](enhanced-networking-ena.md) |
| c5\.18xlarge \| c5\.24xlarge \| c5\.metal \| c5d\.18xlarge \| c5d\.24xlarge \| c5d\.metal \| c6g\.16xlarge \| c6g\.metal \| c6gd\.16xlarge \| c6gd\.metal | 25 Gbps | [ENA](enhanced-networking-ena.md) |
| c5n\.9xlarge | 50 Gbps | [ENA](enhanced-networking-ena.md) |
| c5n\.18xlarge \| c5n\.metal | 100 Gbps | [ENA](enhanced-networking-ena.md) |
| c4\.large | Moderate | [Intel 82599 VF](sriov-networking.md) |
| c4\.xlarge \| c4\.2xlarge \| c4\.4xlarge | High | [Intel 82599 VF](sriov-networking.md) |
| c4\.8xlarge | 10 Gbps | [Intel 82599 VF](sriov-networking.md) | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/compute-optimized-instances.md |
aee626b31575-2 | | c4\.8xlarge | 10 Gbps | [Intel 82599 VF](sriov-networking.md) |
† These instances use a network I/O credit mechanism to allocate network bandwidth to instances based on average bandwidth utilization\. They accrue credits when their bandwidth is below their baseline bandwidth, and can use these credits when they perform network data transfers\. For more information, open a support case and ask about baseline bandwidth for the specific instance types that you are interested in\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/compute-optimized-instances.md |
f68782e82bf7-0 | If you use a Linux AMI with kernel version 4\.4 or later and use all the SSD\-based instance store volumes available to your instance, you get the IOPS \(4,096 byte block size\) performance listed in the following table \(at queue depth saturation\)\. Otherwise, you get lower IOPS performance\.
| Instance Size | 100% Random Read IOPS | Write IOPS |
| --- | --- | --- |
| c5ad\.large | 16,283 | 7,105 |
| c5ad\.xlarge | 32,566 | 14,211 |
| c5ad\.2xlarge | 65,132 | 28,421 |
| c5ad\.4xlarge | 130,263 | 56,842 |
| c5ad\.8xlarge | 260,526 | 113,684 |
| c5ad\.12xlarge | 412,500 | 180,000 |
| c5ad\.16xlarge | 521,053 | 227,368 |
| c5ad\.24xlarge | 825,000 | 360,000 |
| c5d\.large \* | 20,000 | 9,000 |
| c5d\.xlarge \* | 40,000 | 18,000 |
| c5d\.2xlarge \* | 80,000 | 37,000 |
| c5d\.4xlarge \* | 175,000 | 75,000 | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/compute-optimized-instances.md |
f68782e82bf7-1 | | c5d\.4xlarge \* | 175,000 | 75,000 |
| c5d\.9xlarge | 350,000 | 170,000 |
| c5d\.12xlarge | 700,000 | 340,000 |
| c5d\.18xlarge | 700,000 | 340,000 |
| c5d\.24xlarge | 1,400,000 | 680,000 |
| c5d\.metal | 1,400,000 | 680,000 |
| c6gd\.medium | 13,438 | 5,625 |
| c6gd\.large | 26,875 | 11,250 |
| c6gd\.xlarge | 53,750 | 22,500 |
| c6gd\.2xlarge | 107,500 | 45,000 |
| c6gd\.4xlarge | 215,000 | 90,000 |
| c6gd\.8xlarge | 430,000 | 180,000 |
| c6gd\.12xlarge | 645,000 | 270,000 |
| c6gd\.16xlarge | 860,000 | 360,000 |
| c6gd\.metal | 860,000 | 360,000 |
\* For these instances, you can get up to the specified performance\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/compute-optimized-instances.md |
f68782e82bf7-2 | | c6gd\.metal | 860,000 | 360,000 |
\* For these instances, you can get up to the specified performance\.
As you fill the SSD\-based instance store volumes for your instance, the number of write IOPS that you can achieve decreases\. This is due to the extra work the SSD controller must do to find available space, rewrite existing data, and erase unused space so that it can be rewritten\. This process of garbage collection results in internal write amplification to the SSD, expressed as the ratio of SSD write operations to user write operations\. This decrease in performance is even larger if the write operations are not in multiples of 4,096 bytes or not aligned to a 4,096\-byte boundary\. If you write a smaller amount of bytes or bytes that are not aligned, the SSD controller must read the surrounding data and store the result in a new location\. This pattern results in significantly increased write amplification, increased latency, and dramatically reduced I/O performance\.
SSD controllers can use several strategies to reduce the impact of write amplification\. One such strategy is to reserve space in the SSD instance storage so that the controller can more efficiently manage the space available for write operations\. This is called *over\-provisioning*\. The SSD\-based instance store volumes provided to an instance don't have any space reserved for over\-provisioning\. To reduce write amplification, we recommend that you leave 10% of the volume unpartitioned so that the SSD controller can use it for over\-provisioning\. This decreases the storage that you can use, but increases performance even if the disk is close to full capacity\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/compute-optimized-instances.md |
f68782e82bf7-3 | For instance store volumes that support TRIM, you can use the TRIM command to notify the SSD controller whenever you no longer need data that you've written\. This provides the controller with more free space, which can reduce write amplification and increase performance\. For more information, see [Instance store volume TRIM support](ssd-instance-store.md#InstanceStoreTrimSupport)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/compute-optimized-instances.md |
684185e74d32-0 | The following is a summary of features for compute optimized instances:
| | EBS only | NVMe EBS | Instance store | Placement group |
| --- | --- | --- | --- | --- |
| C4 | Yes | No | No | Yes |
| C5 | Yes | Yes | No | Yes |
| C5a | Yes | Yes | No | Yes |
| C5ad | No | Yes | NVMe \* | Yes |
| C5d | No | Yes | NVMe \* | Yes |
| C5n | Yes | Yes | No | Yes |
| C6g | Yes | Yes | No | Yes |
| C6gd | No | Yes | NVMe \* | Yes |
**\*** The root device volume must be an Amazon EBS volume\.
For more information, see the following:
+ [Amazon EBS and NVMe on Linux instances](nvme-ebs-volumes.md)
+ [Amazon EC2 instance store](InstanceStorage.md)
+ [Placement groups](placement-groups.md) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/compute-optimized-instances.md |
75ab5b83aa57-0 | + C5 and C5d instances feature a 3\.1 GHz Intel Xeon Platinum 8000 series processor from either the first generation \(Skylake\-SP\) or second generation \(Cascade Lake\)\.
+ C5a and C5ad instances feature a second\-generation AMD EPYC processor \(Rome\) running at frequencies as high as 3\.3\. GHz\.
+ C6g and C6gd instances feature an AWS Graviton2 processor based on 64\-bit Arm architecture\.
+ C4 instances and instances based on the [Nitro System](instance-types.md#ec2-nitro-instances) require 64\-bit EBS\-backed HVM AMIs\. They have high\-memory and require a 64\-bit operating system to take advantage of that capacity\. HVM AMIs provide superior performance in comparison to paravirtual \(PV\) AMIs on high\-memory instance types\. In addition, you must use an HVM AMI to take advantage of enhanced networking\.
+ Instances built on the Nitro System have the following requirements:
+ [NVMe drivers](nvme-ebs-volumes.md) must be installed
+ [Elastic Network Adapter \(ENA\) drivers](enhanced-networking-ena.md) must be installed
The following Linux AMIs meet these requirements:
+ Amazon Linux 2
+ Amazon Linux AMI 2018\.03
+ Ubuntu 14\.04 \(with `linux-aws` kernel\) or later
+ Red Hat Enterprise Linux 7\.4 or later | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/compute-optimized-instances.md |
75ab5b83aa57-1 | + Ubuntu 14\.04 \(with `linux-aws` kernel\) or later
+ Red Hat Enterprise Linux 7\.4 or later
+ SUSE Linux Enterprise Server 12 SP2 or later
+ CentOS 7\.4\.1708 or later
+ FreeBSD 11\.1 or later
+ Debian GNU/Linux 9 or later
+ Instances with an AWS Graviton processors have the following requirements:
+ Use an AMI for the 64\-bit Arm architecture\.
+ Support booting through UEFI with ACPI tables and support ACPI hot\-plug of PCI devices\.
The following AMIs meet these requirements:
+ Amazon Linux 2 \(64\-bit Arm\)
+ Ubuntu 16\.04 or later \(64\-bit Arm\)
+ Red Hat Enterprise Linux 8\.0 or later \(64\-bit Arm\)
+ SUSE Linux Enterprise Server 15 or later \(64\-bit Arm\)
+ Instances built on the Nitro System instances support a maximum of 28 attachments, including network interfaces, EBS volumes, and NVMe instance store volumes\. For more information, see [Nitro System volume limits](volume_limits.md#instance-type-volume-limits)\.
+ Launching a bare metal instance boots the underlying server, which includes verifying all hardware and firmware components\. This means that it can take 20 minutes from the time the instance enters the running state until it becomes available over the network\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/compute-optimized-instances.md |
75ab5b83aa57-2 | + To attach or detach EBS volumes or secondary network interfaces from a bare metal instance requires PCIe native hotplug support\. Amazon Linux 2 and the latest versions of the Amazon Linux AMI support PCIe native hotplug, but earlier versions do not\. You must enable the following Linux kernel configuration options:
```
CONFIG_HOTPLUG_PCI_PCIE=y
CONFIG_PCIEASPM=y
```
+ Bare metal instances use a PCI\-based serial device rather than an I/O port\-based serial device\. The upstream Linux kernel and the latest Amazon Linux AMIs support this device\. Bare metal instances also provide an ACPI SPCR table to enable the system to automatically use the PCI\-based serial device\. The latest Windows AMIs automatically use the PCI\-based serial device\.
+ Instances built on the Nitro System should have acpid installed to support clean shutdown through API requests\.
+ There is a limit on the total number of instances that you can launch in a Region, and there are additional limits on some instance types\. For more information, see [How many instances can I run in Amazon EC2?](https://aws.amazon.com/ec2/faqs/#How_many_instances_can_I_run_in_Amazon_EC2) in the Amazon EC2 FAQ\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/compute-optimized-instances.md |
6f9f23e1aa95-0 | An *instance store* provides temporary block\-level storage for your instance\. This storage is located on disks that are physically attached to the host computer\. Instance store is ideal for temporary storage of information that changes frequently, such as buffers, caches, scratch data, and other temporary content, or for data that is replicated across a fleet of instances, such as a load\-balanced pool of web servers\.
An instance store consists of one or more instance store volumes exposed as block devices\. The size of an instance store as well as the number of devices available varies by instance type\.
The virtual devices for instance store volumes are `ephemeral[0-23]`\. Instance types that support one instance store volume have `ephemeral0`\. Instance types that support two instance store volumes have `ephemeral0` and `ephemeral1`, and so on\.
![\[Amazon EC2 instance storage\]](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/images/instance_storage.png)
**Topics**
+ [Instance store lifetime](#instance-store-lifetime)
+ [Instance store volumes](#instance-store-volumes)
+ [Add instance store volumes to your EC2 instance](add-instance-store-volumes.md)
+ [SSD instance store volumes](ssd-instance-store.md)
+ [Instance store swap volumes](instance-store-swap-volumes.md)
+ [Optimizing disk performance for instance store volumes](disk-performance.md) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/InstanceStorage.md |
0b9cbeec6a13-0 | You can specify instance store volumes for an instance only when you launch it\. You can't detach an instance store volume from one instance and attach it to a different instance\.
The data in an instance store persists only during the lifetime of its associated instance\. If an instance reboots \(intentionally or unintentionally\), data in the instance store persists\. However, data in the instance store is lost under any of the following circumstances:
+ The underlying disk drive fails
+ The instance stops
+ The instance terminates
Therefore, do not rely on instance store for valuable, long\-term data\. Instead, use more durable data storage, such as Amazon S3, Amazon EBS, or Amazon EFS\.
When you stop or terminate an instance, every block of storage in the instance store is reset\. Therefore, your data cannot be accessed through the instance store of another instance\.
If you create an AMI from an instance, the data on its instance store volumes isn't preserved and isn't present on the instance store volumes of the instances that you launch from the AMI\.
If you change the instance type, an instance store will not be attached to the new instance type\. For more information, see [Changing the instance type](ec2-instance-resize.md)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/InstanceStorage.md |
3d2577ebf6b7-0 | The instance type determines the size of the instance store available and the type of hardware used for the instance store volumes\. Instance store volumes are included as part of the instance's usage cost\. You must specify the instance store volumes that you'd like to use when you launch the instance \(except for NVMe instance store volumes, which are available by default\)\. Then format and mount the instance store volumes before using them\. You can't make an instance store volume available after you launch the instance\. For more information, see [Add instance store volumes to your EC2 instance](add-instance-store-volumes.md)\.
Some instance types use NVMe or SATA\-based solid state drives \(SSD\) to deliver high random I/O performance\. This is a good option when you need storage with very low latency, but you don't need the data to persist when the instance terminates or you can take advantage of fault\-tolerant architectures\. For more information, see [SSD instance store volumes](ssd-instance-store.md)\.
The following table provides the quantity, size, type, and performance optimizations of instance store volumes available on each supported instance type\. For a complete list of instance types, including EBS\-only types, see [Amazon EC2 Instance Types](https://aws.amazon.com/ec2/instance-types/)\.
| Instance type | Instance store volumes | Type | Needs initialization\* | TRIM support\*\* |
| --- | --- | --- | --- | --- |
| c1\.medium | 1 x 350 GB† | HDD | ✔ | | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/InstanceStorage.md |
3d2577ebf6b7-1 | | c1\.medium | 1 x 350 GB† | HDD | ✔ | |
| c1\.xlarge | 4 x 420 GB \(1\.6 TB\) | HDD | ✔ | |
| c3\.large | 2 x 16 GB \(32 GB\) | SSD | ✔ | |
| c3\.xlarge | 2 x 40 GB \(80 GB\) | SSD | ✔ | |
| c3\.2xlarge | 2 x 80 GB \(160 GB\) | SSD | ✔ | |
| c3\.4xlarge | 2 x 160 GB \(320 GB\) | SSD | ✔ | |
| c3\.8xlarge | 2 x 320 GB \(640 GB\) | SSD | ✔ | |
| c5ad\.large | 1 x 75 GB | NVMe SSD | | ✔ |
| c5ad\.xlarge | 1 x 150 GB | NVMe SSD | | ✔ |
| c5ad\.2xlarge | 1 x 300 GB | NVMe SSD | | ✔ |
| c5ad\.4xlarge | 2 x 300 GB \(600 GB\) | NVMe SSD | | ✔ |
| c5ad\.8xlarge | 2 x 600 GB \(1\.2 TB\) | NVMe SSD | | ✔ |
| c5ad\.12xlarge | 2 x 900 GB \(1\.8 TB\) | NVMe SSD | | ✔ | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/InstanceStorage.md |
3d2577ebf6b7-2 | | c5ad\.12xlarge | 2 x 900 GB \(1\.8 TB\) | NVMe SSD | | ✔ |
| c5ad\.16xlarge | 2 x 1\.2 TB \(2\.4 TB\) | NVMe SSD | | ✔ |
| c5ad\.24xlarge | 2 x 1\.9 TB \(3\.8 TB\) | NVMe SSD | | ✔ |
| c5d\.large | 1 x 50 GB | NVMe SSD | | ✔ |
| c5d\.xlarge | 1 x 100 GB | NVMe SSD | | ✔ |
| c5d\.2xlarge | 1 x 200 GB | NVMe SSD | | ✔ |
| c5d\.4xlarge | 1 x 400 GB | NVMe SSD | | ✔ |
| c5d\.9xlarge | 1 x 900 GB | NVMe SSD | | ✔ |
| c5d\.12xlarge | 2 x 900 GB \(1\.8 TB\) | NVMe SSD | | ✔ |
| c5d\.18xlarge | 2 x 900 GB \(1\.8 TB\) | NVMe SSD | | ✔ |
| c5d\.24xlarge | 4 x 900 GB \(3\.6 TB\) | NVMe SSD | | ✔ | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/InstanceStorage.md |
3d2577ebf6b7-3 | | c5d\.24xlarge | 4 x 900 GB \(3\.6 TB\) | NVMe SSD | | ✔ |
| c5d\.metal | 4 x 900 GB \(3\.6 TB\) | NVMe SSD | | ✔ |
| c6gd\.medium | 1 x 59 GB | NVMe SSD | | ✔ |
| c6gd\.large | 1 x 118 GB | NVMe SSD | | ✔ |
| c6gd\.xlarge | 1 x 237 GB | NVMe SSD | | ✔ |
| c6gd\.2xlarge | 1 x 474 GB | NVMe SSD | | ✔ |
| c6gd\.4xlarge | 1 x 950 GB | NVMe SSD | | ✔ |
| c6gd\.8xlarge | 1 x 1900 GB | NVMe SSD | | ✔ |
| c6gd\.12xlarge | 2 x 1425 GB \(2\.85 TB\) | NVMe SSD | | ✔ |
| c6gd\.16xlarge | 2 x 1900 GB \(3\.8 TB\) | NVMe SSD | | ✔ |
| c6gd\.metal | 2 x 1900 GB \(3\.8 TB\) | NVMe SSD | | ✔ |
| cc2\.8xlarge | 4 x 840 GB \(3\.36 TB\) | HDD | ✔ | | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/InstanceStorage.md |
3d2577ebf6b7-4 | | cc2\.8xlarge | 4 x 840 GB \(3\.36 TB\) | HDD | ✔ | |
| cr1\.8xlarge | 2 x 120 GB \(240 GB\) | SSD | ✔ | |
| d2\.xlarge | 3 x 2,000 GB \(6 TB\) | HDD | | |
| d2\.2xlarge | 6 x 2,000 GB \(12 TB\) | HDD | | |
| d2\.4xlarge | 12 x 2,000 GB \(24 TB\) | HDD | | |
| d2\.8xlarge | 24 x 2,000 GB \(48 TB\) | HDD | | |
| f1\.2xlarge | 1 x 470 GB | NVMe SSD | | ✔ |
| f1\.4xlarge | 1 x 940 GB | NVMe SSD | | ✔ |
| f1\.16xlarge | 4 x 940 GB \(3\.76 TB\) | NVMe SSD | | ✔ |
| g2\.2xlarge | 1 x 60 GB | SSD | ✔ | |
| g2\.8xlarge | 2 x 120 GB \(240 GB\) | SSD | ✔ | |
| g4dn\.xlarge | 1 x 125 GB | NVMe SSD | | ✔ |
| g4dn\.2xlarge | 1 x 225 GB | NVMe SSD | | ✔ | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/InstanceStorage.md |
3d2577ebf6b7-5 | | g4dn\.2xlarge | 1 x 225 GB | NVMe SSD | | ✔ |
| g4dn\.4xlarge | 1 x 225 GB | NVMe SSD | | ✔ |
| g4dn\.8xlarge | 1 x 900 GB | NVMe SSD | | ✔ |
| g4dn\.12xlarge | 1 x 900 GB | NVMe SSD | | ✔ |
| g4dn\.16xlarge | 1 x 900 GB | NVMe SSD | | ✔ |
| g4dn\.metal | 2 x 900 GB \(1\.8 TB\) | NVMe SSD | | ✔ |
| h1\.2xlarge | 1 x 2000 GB \(2 TB\) | HDD | | |
| h1\.4xlarge | 2 x 2000 GB \(4 TB\) | HDD | | |
| h1\.8xlarge | 4 x 2000 GB \(8 TB\) | HDD | | |
| h1\.16xlarge | 8 x 2000 GB \(16 TB\) | HDD | | |
| hs1\.8xlarge | 24 x 2,000 GB \(48 TB\) | HDD | ✔ | |
| i2\.xlarge | 1 x 800 GB | SSD | | ✔ |
| i2\.2xlarge | 2 x 800 GB \(1\.6 TB\) | SSD | | ✔ | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/InstanceStorage.md |
3d2577ebf6b7-6 | | i2\.2xlarge | 2 x 800 GB \(1\.6 TB\) | SSD | | ✔ |
| i2\.4xlarge | 4 x 800 GB \(3\.2 TB\) | SSD | | ✔ |
| i2\.8xlarge | 8 x 800 GB \(6\.4 TB\) | SSD | | ✔ |
| i3\.large | 1 x 475 GB | NVMe SSD | | ✔ |
| i3\.xlarge | 1 x 950 GB | NVMe SSD | | ✔ |
| i3\.2xlarge | 1 x 1,900 GB | NVMe SSD | | ✔ |
| i3\.4xlarge | 2 x 1,900 GB \(3\.8 TB\) | NVMe SSD | | ✔ |
| i3\.8xlarge | 4 x 1,900 GB \(7\.6 TB\) | NVMe SSD | | ✔ |
| i3\.16xlarge | 8 x 1,900 GB \(15\.2 TB\) | NVMe SSD | | ✔ |
| i3\.metal | 8 x 1,900 GB \(15\.2 TB\) | NVMe SSD | | ✔ |
| i3en\.large | 1 x 1,250 GB | NVMe SSD | | ✔ |
| i3en\.xlarge | 1 x 2,500 GB | NVMe SSD | | ✔ | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/InstanceStorage.md |
3d2577ebf6b7-7 | | i3en\.xlarge | 1 x 2,500 GB | NVMe SSD | | ✔ |
| i3en\.2xlarge | 2 x 2,500 GB \(5 TB\) | NVMe SSD | | ✔ |
| i3en\.3xlarge | 1 x 7,500 GB | NVMe SSD | | ✔ |
| i3en\.6xlarge | 2 x 7,500 GB \(15 TB\) | NVMe SSD | | ✔ |
| i3en\.12xlarge | 4 x 7,500 GB \(30 TB\) | NVMe SSD | | ✔ |
| i3en\.24xlarge | 8 x 7,500 GB \(60 TB\) | NVMe SSD | | ✔ |
| i3en\.metal | 8 x 7,500 GB \(60 TB\) | NVMe SSD | | ✔ |
| m1\.small | 1 x 160 GB† | HDD | ✔ | |
| m1\.medium | 1 x 410 GB | HDD | ✔ | |
| m1\.large | 2 x 420 GB \(840 GB\) | HDD | ✔ | |
| m1\.xlarge | 4 x 420 GB \(1\.6 TB\) | HDD | ✔ | |
| m2\.xlarge | 1 x 420 GB | HDD | ✔ | |
| m2\.2xlarge | 1 x 850 GB | HDD | ✔ | | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/InstanceStorage.md |
3d2577ebf6b7-8 | | m2\.2xlarge | 1 x 850 GB | HDD | ✔ | |
| m2\.4xlarge | 2 x 840 GB \(1\.68 TB\) | HDD | ✔ | |
| m3\.medium | 1 x 4 GB | SSD | ✔ | |
| m3\.large | 1 x 32 GB | SSD | ✔ | |
| m3\.xlarge | 2 x 40 GB \(80 GB\) | SSD | ✔ | |
| m3\.2xlarge | 2 x 80 GB \(160 GB\) | SSD | ✔ | |
| m5ad\.large | 1 x 75 GB | NVMe SSD | | ✔ |
| m5ad\.xlarge | 1 x 150 GB | NVMe SSD | | ✔ |
| m5ad\.2xlarge | 1 x 300 GB | NVMe SSD | | ✔ |
| m5ad\.4xlarge | 2 x 300 GB \(600 GB\) | NVMe SSD | | ✔ |
| m5ad\.8xlarge | 2 x 600 GB \(1\.2 TB\) | NVMe SSD | | ✔ |
| m5ad\.12xlarge | 2 x 900 GB \(1\.8 TB\) | NVMe SSD | | ✔ |
| m5ad\.16xlarge | 4 x 600 GB \(2\.4 TB\) | NVMe SSD | | ✔ | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/InstanceStorage.md |
3d2577ebf6b7-9 | | m5ad\.16xlarge | 4 x 600 GB \(2\.4 TB\) | NVMe SSD | | ✔ |
| m5ad\.24xlarge | 4 x 900 GB \(3\.6 TB\) | NVMe SSD | | ✔ |
| m5d\.large | 1 x 75 GB | NVMe SSD | | ✔ |
| m5d\.xlarge | 1 x 150 GB | NVMe SSD | | ✔ |
| m5d\.2xlarge | 1 x 300 GB | NVMe SSD | | ✔ |
| m5d\.4xlarge | 2 x 300 GB \(600 GB\) | NVMe SSD | | ✔ |
| m5d\.8xlarge | 2 x 600 GB \(1\.2 TB\) | NVMe SSD | | ✔ |
| m5d\.12xlarge | 2 x 900 GB \(1\.8 TB\) | NVMe SSD | | ✔ |
| m5d\.16xlarge | 4 x 600 GB \(2\.4 TB\) | NVMe SSD | | ✔ |
| m5d\.24xlarge | 4 x 900 GB \(3\.6 TB\) | NVMe SSD | | ✔ |
| m5d\.metal | 4 x 900 GB \(3\.6 TB\) | NVMe SSD | | ✔ | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/InstanceStorage.md |
3d2577ebf6b7-10 | | m5d\.metal | 4 x 900 GB \(3\.6 TB\) | NVMe SSD | | ✔ |
| m5dn\.large | 1 x 75 GB | NVMe SSD | | ✔ |
| m5dn\.xlarge | 1 x 150 GB | NVMe SSD | | ✔ |
| m5dn\.2xlarge | 1 x 300 GB | NVMe SSD | | ✔ |
| m5dn\.4xlarge | 2 x 300 GB \(600 GB\) | NVMe SSD | | ✔ |
| m5dn\.8xlarge | 2 x 600 GB \(1\.2 TB\) | NVMe SSD | | ✔ |
| m5dn\.12xlarge | 2 x 900 GB \(1\.8 TB\) | NVMe SSD | | ✔ |
| m5dn\.16xlarge | 4 x 600 GB \(2\.4 TB\) | NVMe SSD | | ✔ |
| m5dn\.24xlarge | 4 x 900 GB \(3\.6 TB\) | NVMe SSD | | ✔ |
| m6gd\.medium | 1 x 59 GB | NVMe SSD | | ✔ |
| m6gd\.large | 1 x 118 GB | NVMe SSD | | ✔ |
| m6gd\.xlarge | 1 x 237 GB | NVMe SSD | | ✔ | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/InstanceStorage.md |
3d2577ebf6b7-11 | | m6gd\.xlarge | 1 x 237 GB | NVMe SSD | | ✔ |
| m6gd\.2xlarge | 1 x 474 GB | NVMe SSD | | ✔ |
| m6gd\.4xlarge | 1 x 950 GB | NVMe SSD | | ✔ |
| m6gd\.8xlarge | 1 x 1900 GB | NVMe SSD | | ✔ |
| m6gd\.12xlarge | 2 x 1425 GB \(2\.85 TB\) | NVMe SSD | | ✔ |
| m6gd\.16xlarge | 2 x 1900 GB \(3\.8 TB\) | NVMe SSD | | ✔ |
| m6gd\.metal | 2 x 1900 GB \(3\.8 TB\) | NVMe SSD | | ✔ |
| p3dn\.24xlarge | 2 x 900 GB \(1\.8 TB\) | NVMe SSD | | ✔ |
| r3\.large | 1 x 32 GB | SSD | | ✔ |
| r3\.xlarge | 1 x 80 GB | SSD | | ✔ |
| r3\.2xlarge | 1 x 160 GB | SSD | | ✔ |
| r3\.4xlarge | 1 x 320 GB | SSD | | ✔ |
| r3\.8xlarge | 2 x 320 GB \(640 GB\) | SSD | | ✔ | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/InstanceStorage.md |
3d2577ebf6b7-12 | | r3\.8xlarge | 2 x 320 GB \(640 GB\) | SSD | | ✔ |
| r5ad\.large | 1 x 75 GB | NVMe SSD | | ✔ |
| r5ad\.xlarge | 1 x 150 GB | NVMe SSD | | ✔ |
| r5ad\.2xlarge | 1 x 300 GB | NVMe SSD | | ✔ |
| r5ad\.4xlarge | 2 x 300 GB \(600 GB\) | NVMe SSD | | ✔ |
| r5ad\.8xlarge | 2 x 600 GB \(1\.2 TB\) | NVMe SSD | | ✔ |
| r5ad\.12xlarge | 2 x 900 GB \(1\.8 TB\) | NVMe SSD | | ✔ |
| r5ad\.16xlarge | 4 x 600 GB \(2\.4 TB\) | NVMe SSD | | ✔ |
| r5ad\.24xlarge | 4 x 900 GB \(3\.6 TB\) | NVMe SSD | | ✔ |
| r5d\.large | 1 x 75 GB | NVMe SSD | | ✔ |
| r5d\.xlarge | 1 x 150 GB | NVMe SSD | | ✔ |
| r5d\.2xlarge | 1 x 300 GB | NVMe SSD | | ✔ | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/InstanceStorage.md |
3d2577ebf6b7-13 | | r5d\.2xlarge | 1 x 300 GB | NVMe SSD | | ✔ |
| r5d\.4xlarge | 2 x 300 GB \(600 GB\) | NVMe SSD | | ✔ |
| r5d\.8xlarge | 2 x 600 GB \(1\.2 TB\) | NVMe SSD | | ✔ |
| r5d\.12xlarge | 2 x 900 GB \(1\.8 TB\) | NVMe SSD | | ✔ |
| r5d\.16xlarge | 4 x 600 GB \(2\.4 TB\) | NVMe SSD | | ✔ |
| r5d\.24xlarge | 4 x 900 GB \(3\.6 TB\) | NVMe SSD | | ✔ |
| r5d\.metal | 4 x 900 GB \(3\.6 TB\) | NVMe SSD | | ✔ |
| r5dn\.large | 1 x 75 GB | NVMe SSD | | ✔ |
| r5dn\.xlarge | 1 x 150 GB | NVMe SSD | | ✔ |
| r5dn\.2xlarge | 1 x 300 GB | NVMe SSD | | ✔ |
| r5dn\.4xlarge | 2 x 300 GB \(600 GB\) | NVMe SSD | | ✔ | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/InstanceStorage.md |
3d2577ebf6b7-14 | | r5dn\.4xlarge | 2 x 300 GB \(600 GB\) | NVMe SSD | | ✔ |
| r5dn\.8xlarge | 2 x 600 GB \(1\.2 TB\) | NVMe SSD | | ✔ |
| r5dn\.12xlarge | 2 x 900 GB \(1\.8 TB\) | NVMe SSD | | ✔ |
| r5dn\.16xlarge | 4 x 600 GB \(2\.4 TB\) | NVMe SSD | | ✔ |
| r5dn\.24xlarge | 4 x 900 GB \(3\.6 TB\) | NVMe SSD | | ✔ |
| r6gd\.medium | 1 x 59 GB | NVMe SSD | | ✔ |
| r6gd\.large | 1 x 118 GB | NVMe SSD | | ✔ |
| r6gd\.xlarge | 1 x 237 GB | NVMe SSD | | ✔ |
| r6gd\.2xlarge | 1 x 474 GB | NVMe SSD | | ✔ |
| r6gd\.4xlarge | 1 x 950 GB | NVMe SSD | | ✔ |
| r6gd\.8xlarge | 1 x 1900 GB | NVMe SSD | | ✔ | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/InstanceStorage.md |
3d2577ebf6b7-15 | | r6gd\.8xlarge | 1 x 1900 GB | NVMe SSD | | ✔ |
| r6gd\.12xlarge | 2 x 1425 GB \(2\.85 TB\) | NVMe SSD | | ✔ |
| r6gd\.16xlarge | 2 x 1900 GB \(3\.8 TB\) | NVMe SSD | | ✔ |
| r6gd\.metal | 2 x 1900 GB \(3\.8 TB\) | NVMe SSD | | ✔ |
| x1\.16xlarge | 1 x 1,920 GB | SSD | | |
| x1\.32xlarge | 2 x 1,920 GB \(3\.84 TB\) | SSD | | |
| x1e\.xlarge | 1 x 120 GB | SSD | | |
| x1e\.2xlarge | 1 x 240 GB | SSD | | |
| x1e\.4xlarge | 1 x 480 GB | SSD | | |
| x1e\.8xlarge | 1 x 960 GB | SSD | | |
| x1e\.16xlarge | 1 x 1,920 GB | SSD | | |
| x1e\.32xlarge | 2 x 1,920 GB \(3\.84 TB\) | SSD | | |
| z1d\.large | 1 x 75 GB | NVMe SSD | | ✔ | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/InstanceStorage.md |
3d2577ebf6b7-16 | | z1d\.large | 1 x 75 GB | NVMe SSD | | ✔ |
| z1d\.xlarge | 1 x 150 GB | NVMe SSD | | ✔ |
| z1d\.2xlarge | 1 x 300 GB | NVMe SSD | | ✔ |
| z1d\.3xlarge | 1 x 450 GB | NVMe SSD | | ✔ |
| z1d\.6xlarge | 1 x 900 GB | NVMe SSD | | ✔ |
| z1d\.12xlarge | 2 x 900 GB \(1\.8 TB\) | NVMe SSD | | ✔ |
| z1d\.metal | 2 x 900 GB \(1\.8 TB\) | NVMe SSD | | ✔ |
\* Volumes attached to certain instances suffer a first\-write penalty unless initialized\. For more information, see [Optimizing disk performance for instance store volumes](disk-performance.md)\.
\*\* For more information, see [Instance store volume TRIM support](ssd-instance-store.md#InstanceStoreTrimSupport)\.
† The `c1.medium` and `m1.small` instance types also include a 900 MB instance store swap volume, which may not be automatically enabled at boot time\. For more information, see [Instance store swap volumes](instance-store-swap-volumes.md)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/InstanceStorage.md |
3bba96711123-0 | The Amazon EC2 console provides a **Launch More Like This** wizard option that enables you to use a current instance as a base for launching other instances\. This option automatically populates the Amazon EC2 launch wizard with certain configuration details from the selected instance\.
**Note**
The **Launch More Like This** wizard option does not clone your selected instance; it only replicates some configuration details\. To create a copy of your instance, first create an AMI from it, then launch more instances from the AMI\.
Alternatively, create a [launch template](ec2-launch-templates.md) to store the launch parameters for your instances\.
The following configuration details are copied from the selected instance into the launch wizard:
+ AMI ID
+ Instance type
+ Availability Zone, or the VPC and subnet in which the selected instance is located
+ Public IPv4 address\. If the selected instance currently has a public IPv4 address, the new instance receives a public IPv4 address \- regardless of the selected instance's default public IPv4 address setting\. For more information about public IPv4 addresses, see [Public IPv4 addresses and external DNS hostnames](using-instance-addressing.md#concepts-public-addresses)\.
+ Placement group, if applicable
+ IAM role associated with the instance, if applicable
+ Shutdown behavior setting \(stop or terminate\)
+ Termination protection setting \(true or false\)
+ CloudWatch monitoring \(enabled or disabled\)
+ Amazon EBS\-optimization setting \(true or false\) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/launch-more-like-this.md |
3bba96711123-1 | + CloudWatch monitoring \(enabled or disabled\)
+ Amazon EBS\-optimization setting \(true or false\)
+ Tenancy setting, if launching into a VPC \(shared or dedicated\)
+ Kernel ID and RAM disk ID, if applicable
+ User data, if specified
+ Tags associated with the instance, if applicable
+ Security groups associated with the instance
The following configuration details are not copied from your selected instance; instead, the wizard applies their default settings or behavior:
+ Number of network interfaces: The default is one network interface, which is the primary network interface \(eth0\)\.
+ Storage: The default storage configuration is determined by the AMI and the instance type\.
**To use your current instance as a template**
1. On the Instances page, select the instance you want to use\.
1. Choose **Actions**, and then **Launch More Like This**\.
1. The launch wizard opens on the **Review Instance Launch** page\. You can check the details of your instance, and make any necessary changes by clicking the appropriate **Edit** link\.
When you are ready, choose **Launch** to select a key pair and launch your instance\.
1. If the instance fails to launch or the state immediately goes to `terminated` instead of `running`, see [Troubleshooting instance launch issues](troubleshooting-launch.md)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/launch-more-like-this.md |
f448acaef804-0 | Modules are written in YAML, a data serialization standard\. A module's YAML file consists of a single document, representing the module and its attributes\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2rl_moduledev.md |
0539871f7e50-0 | The following table lists the available module attributes\.
| Attribute | Description |
| --- | --- |
| name | The name of the module\. The name should be less than or equal to 18 characters in length\. |
| version | The version number of the module\. |
| title | A short, descriptive title for the module\. This value should be less than or equal to 50 characters in length\. |
| helptext | The extended description of the module\. Each line should be less than or equal to 75 characters in length\. If the module consumes arguments, required or optional, include them in the helptext value\. For example:<pre>helptext: !!str |<br /> Collect output from ps for system analysis<br /> Consumes --times= for number of times to repeat<br /> Consumes --period= for time period between repetition</pre> |
| placement | The stage in which the module should be run\. Supported values:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2rl_moduledev.html) |
| language | The language that the module code is written in\. Supported values:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2rl_moduledev.html) Python code must be compatible with both Python 2\.7\.9\+ and Python 3\.2\+\. | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2rl_moduledev.md |
0539871f7e50-1 | | remediation | Indicates whether the module supports remediation\. Supported values are `True` or `False`\. The module defaults to `False` if this is absent, making it an optional attribute for those modules that do not support remediation\. |
| content | The entirety of the script code\. |
| constraint | The name of the object containing the constraint values\. |
| domain | A descriptor of how the module is grouped or classified\. The set of included modules uses the following domains: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2rl_moduledev.html) |
| class | A descriptor of the type of task performed by the module\. The set of included modules uses the following classes: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2rl_moduledev.html) |
| distro | The list of Linux distributions that this module supports\. The set of included modules uses the following distributions: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2rl_moduledev.html) |
| required | The required arguments that the module is consuming from the CLI options\. |
| optional | The optional arguments that the module can use\. | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2rl_moduledev.md |
0539871f7e50-2 | | required | The required arguments that the module is consuming from the CLI options\. |
| optional | The optional arguments that the module can use\. |
| software | The software executables used in the module\. This attribute is intended to specify software that is not installed by default\. The EC2Rescue for Linux logic ensures that these programs are present and executable before running the module\. |
| package | The source software package for an executable\. This attribute is intended to provide extended details on the package with the software, including a URL for downloading or getting further information\. |
| sudo | Indicates whether root access is required to run the module\. You do not need to implement sudo checks in the module script\. If the value is true, then the EC2Rescue for Linux logic only runs the module when the executing user has root access\. |
| perfimpact | Indicates whether the module can have significant performance impact upon the environment in which it is run\. If the value is true and the `--perfimpact=true` argument is not present, then the module is skipped\. |
| parallelexclusive | Specifies a program that requires mutual exclusivity\. For example, all modules specifying "bpf" run in a serial manner\. | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2rl_moduledev.md |
bfd387fb72cd-0 | The following table lists the available environment variables\.
| Environment Variable | Description |
| --- | --- |
| `EC2RL_CALLPATH` | The path to ec2rl\.py\. This path can be used to locate the lib directory and use vendored Python modules\. |
| `EC2RL_WORKDIR` | The main tmp directory for the diagnostic tool\. Default value: `/var/tmp/ec2rl`\. |
| `EC2RL_RUNDIR` | The directory where all output is stored\. Default value: `/var/tmp/ec2rl/<date×tamp>`\. |
| `EC2RL_GATHEREDDIR` | The root directory for placing gathered module data\. Default value:`/var/tmp/ec2rl/<date×tamp>/mod_out/gathered/`\. |
| `EC2RL_NET_DRIVER` | The driver in use for the first, alphabetically ordered, non\-virtual network interface on the instance\. Examples: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2rl_moduledev.html) |
| `EC2RL_SUDO` | True if EC2Rescue for Linux is running as root; otherwise, false\. | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2rl_moduledev.md |
bfd387fb72cd-1 | | `EC2RL_SUDO` | True if EC2Rescue for Linux is running as root; otherwise, false\. |
| `EC2RL_VIRT_TYPE` | The virtualization type as provided by the instance metadata\. Examples: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2rl_moduledev.html) |
| `EC2RL_INTERFACES` | An enumerated list of interfaces on the system\. The value is a string containing names, such as `eth0`, `eth1`, etc\. This is generated via the `functions.bash` and is only available for modules that have sourced it\. | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2rl_moduledev.md |
25a1552f583d-0 | The following should be noted when constructing your module YAML files:
+ The triple hyphen \(`---`\) denotes the explicit start of a document\.
+ The `!ec2rlcore.module.Module` tag tells the YAML parser which constructor to call when creating the object from the data stream\. You can find the constructor inside the `module.py` file\.
+ The `!!str` tag tells the YAML parser to not attempt to determine the type of data, and instead interpret the content as a string literal\.
+ The pipe character \(`|`\) tells the YAML parser that the value is a literal\-style scalar\. In this case, the parser includes all whitespace\. This is important for modules because indentation and newline characters are kept\.
+ The YAML standard indent is two spaces, which can be seen in the following examples\. Ensure that you maintain standard indentation \(for example, four spaces for Python\) for your script and then indent the entire content two spaces inside the module file\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2rl_moduledev.md |
bf52b09bf09d-0 | Example one \(`mod.d/ps.yaml`\):
```
--- !ec2rlcore.module.Module | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2rl_moduledev.md |
c11b97e23d46-0 | name: !!str ps
path: !!str
version: !!str 1.0
title: !!str Collect output from ps for system analysis
helptext: !!str |
Collect output from ps for system analysis
Requires --times= for number of times to repeat
Requires --period= for time period between repetition
placement: !!str run
package:
- !!str
language: !!str bash
content: !!str |
#!/bin/bash
error_trap()
{
printf "%0.s=" {1..80}
echo -e "\nERROR: "$BASH_COMMAND" exited with an error on line ${BASH_LINENO[0]}"
exit 0
}
trap error_trap ERR | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2rl_moduledev.md |
84f0e05cd371-0 | source functions.bash
echo "I will collect ps output from this $EC2RL_DISTRO box for $times times every $period seconds."
for i in $(seq 1 $times); do
ps auxww
sleep $period
done
constraint:
requires_ec2: !!str False
domain: !!str performance
class: !!str collect
distro: !!str alami ubuntu rhel suse
required: !!str period times
optional: !!str
software: !!str
sudo: !!str False
perfimpact: !!str False
parallelexclusive: !!str
``` | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2rl_moduledev.md |
95f96ef86e3a-0 | As your needs change, you might find that your instance is over\-utilized \(the instance type is too small\) or under\-utilized \(the instance type is too large\)\. If this is the case, you can change the size of your instance\. For example, if your `t2.micro` instance is too small for its workload, you can change it to another instance type that is appropriate for the workload\.
You might also want to migrate from a previous generation instance type to a current generation instance type to take advantage of some features; for example, support for IPv6\.
If the root device for your instance is an EBS volume, you can change the size of the instance simply by changing its instance type, which is known as *resizing* it\. If the root device for your instance is an instance store volume, you must migrate your application to a new instance with the instance type that you need\. For more information about root device volumes, see [Storage for the root device](ComponentsAMIs.md#storage-for-the-root-device)\.
When you resize an instance, you must select an instance type that is compatible with the configuration of the instance\. If the instance type that you want is not compatible with the instance configuration you have, then you must migrate your application to a new instance with the instance type that you need\.
**Important** | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-resize.md |
95f96ef86e3a-1 | **Important**
When you resize an instance, the resized instance usually has the same number of instance store volumes that you specified when you launched the original instance\. With instance types that support NVMe instance store volumes \(which are available by default\), the resized instance might have additional instance store volumes, depending on the AMI\. Otherwise, you can migrate your application to an instance with a new instance type manually, specifying the number of instance store volumes that you need when you launch the new instance\.
**Topics**
+ [Compatibility for resizing instances](#resize-limitations)
+ [Resizing an Amazon EBS–backed instance](#resize-ebs-backed-instance)
+ [Migrating an instance store\-backed instance](#resize-instance-store-backed-instance)
+ [Migrating to a new instance configuration](#migrate-instance-configuration) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-resize.md |
f790aa352f7b-0 | You can resize an instance only if its current instance type and the new instance type that you want are compatible in the following ways:
+ **Virtualization type**: Linux AMIs use one of two types of virtualization: paravirtual \(PV\) or hardware virtual machine \(HVM\)\. You can't resize an instance that was launched from a PV AMI to an instance type that is HVM only\. For more information, see [Linux AMI virtualization types](virtualization_types.md)\. To check the virtualization type of your instance, see the **Virtualization** field on the details pane of the **Instances** screen in the Amazon EC2 console\.
+ **Architecture**: AMIs are specific to the architecture of the processor, so you must select an instance type with the same processor architecture as the current instance type\. For example:
+ If you are resizing an instance type with a processor based on the Arm architecture, you are limited to the instance types that support a processor based on the Arm architecture, such as A1 and M6g\.
+ The following instance types are the only instance types that support 32\-bit AMIs: `t2.nano`, `t2.micro`, `t2.small`, `t2.medium`, `c3.large`, `t1.micro`, `m1.small`, `m1.medium`, and `c1.medium`\. If you are resizing a 32\-bit instance, you are limited to these instance types\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-resize.md |
f790aa352f7b-1 | + **Network**: Newer instance types must be launched in a VPC\. Therefore, you can't resize an instance in the EC2\-Classic platform to a instance type that is available only in a VPC unless you have a nondefault VPC\. To check whether your instance is in a VPC, check the **VPC ID** value on the details pane of the **Instances** screen in the Amazon EC2 console\. For more information, see [Migrating from EC2\-Classic to a VPC](vpc-migrate.md)\.
+ **Enhanced networking**: Instance types that support [enhanced networking](enhanced-networking.md) require the necessary drivers installed\. For example, instances based on the [Nitro System](instance-types.md#ec2-nitro-instances) require EBS\-backed AMIs with the Elastic Network Adapter \(ENA\) drivers installed\. To resize an instance from a type that does not support enhanced networking to a type that supports enhanced networking, you must install the [ENA drivers](enhanced-networking-ena.md) or [ixgbevf drivers](sriov-networking.md) on the instance, as appropriate\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-resize.md |
f790aa352f7b-2 | + **NVMe**: EBS volumes are exposed as NVMe block devices on instances built on the [Nitro System](instance-types.md#ec2-nitro-instances)\. If you resize an instance from an instance type that does not support NVMe to an instance type that supports NVMe, you must first install the [NVMe drivers](nvme-ebs-volumes.md) on your instance\. Also, the device names for devices that you specify in the block device mapping are renamed using NVMe device names \(`/dev/nvme[0-26]n1`\)\. Therefore, to mount file systems at boot time using `/etc/fstab`, you must use UUID/Label instead of device names\.
+ **AMI**: For information about the AMIs required by instance types that support enhanced networking and NVMe, see the Release Notes in the following documentation:
+ [General purpose instances](general-purpose-instances.md)
+ [Compute optimized instances](compute-optimized-instances.md)
+ [Memory optimized instances](memory-optimized-instances.md)
+ [Storage optimized instances](storage-optimized-instances.md) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-resize.md |
37a618714fe1-0 | You must stop your Amazon EBS–backed instance before you can change its instance type\. When you stop and start an instance, be aware of the following:
+ We move the instance to new hardware; however, the instance ID does not change\.
+ If your instance has a public IPv4 address, we release the address and give it a new public IPv4 address\. The instance retains its private IPv4 addresses, any Elastic IP addresses, and any IPv6 addresses\.
+ If your instance is in an Auto Scaling group, the Amazon EC2 Auto Scaling service marks the stopped instance as unhealthy, and may terminate it and launch a replacement instance\. To prevent this, you can suspend the scaling processes for the group while you're resizing your instance\. For more information, see [Suspending and Resuming Scaling Processes](https://docs.aws.amazon.com/autoscaling/latest/userguide/as-suspend-resume-processes.html) in the *Amazon EC2 Auto Scaling User Guide*\.
+ If your instance is in a [cluster placement group](placement-groups.md#placement-groups-cluster) and, after changing the instance type, the instance start fails, try the following: stop all the instances in the cluster placement group, change the instance type for the affected instance, and then restart all the instances in the cluster placement group\.
+ Ensure that you plan for downtime while your instance is stopped\. Stopping and resizing an instance may take a few minutes, and restarting your instance may take a variable amount of time depending on your application's startup scripts\.
For more information, see [Stop and start your instance](Stop_Start.md)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-resize.md |
37a618714fe1-1 | For more information, see [Stop and start your instance](Stop_Start.md)\.
Use the following procedure to resize an Amazon EBS–backed instance using the AWS Management Console\.
**To resize an Amazon EBS–backed instance**
1. \(Optional\) If the new instance type requires drivers that are not installed on the existing instance, you must connect to your instance and install the drivers first\. For more information, see [Compatibility for resizing instances](#resize-limitations)\.
1. Open the Amazon EC2 console\.
1. In the navigation pane, choose **Instances**\.
1. Select the instance and choose **Actions**, **Instance State**, **Stop**\.
1. In the confirmation dialog box, choose **Yes, Stop**\. It can take a few minutes for the instance to stop\.
1. With the instance still selected, choose **Actions**, **Instance Settings**, **Change Instance Type**\. This action is disabled if the instance state is not `stopped`\.
1. In the **Change Instance Type** dialog box, do the following:
1. From **Instance Type**, select the instance type that you want\. If the instance type that you want does not appear in the list, then it is not compatible with the configuration of your instance \(for example, because of virtualization type\)\. For more information, see [Compatibility for resizing instances](#resize-limitations)\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-resize.md |
37a618714fe1-2 | 1. \(Optional\) If the instance type that you selected supports EBS–optimization, select **EBS\-optimized** to enable EBS–optimization or deselect **EBS\-optimized** to disable EBS–optimization\. If the instance type that you selected is EBS–optimized by default, **EBS\-optimized** is selected and you can't deselect it\.
1. Choose **Apply** to accept the new settings\.
1. To restart the stopped instance, select the instance and choose **Actions**, **Instance State**, **Start**\.
1. In the confirmation dialog box, choose **Yes, Start**\. It can take a few minutes for the instance to enter the `running` state\.
1. \(Troubleshooting\) If your instance won't boot, it is possible that one of the requirements for the new instance type was not met\. For more information, see [Why is my Linux instance not booting after I changed its type?](https://aws.amazon.com/premiumsupport/knowledge-center/boot-error-linux-m5-c5/) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-resize.md |
c6a516a42ec5-0 | When you want to move your application from one instance store\-backed instance to an instance store\-backed instance with a different instance type, you must migrate it by creating an image from your instance, and then launching a new instance from this image with the instance type that you need\. To ensure that your users can continue to use the applications that you're hosting on your instance uninterrupted, you must take any Elastic IP address that you've associated with your original instance and associate it with the new instance\. Then you can terminate the original instance\.
**To migrate an instance store\-backed instance**
1. Back up any data on your instance store volumes that you need to keep to persistent storage\. To migrate data on your EBS volumes that you need to keep, take a snapshot of the volumes \(see [Creating Amazon EBS snapshots](ebs-creating-snapshot.md)\) or detach the volume from the instance so that you can attach it to the new instance later \(see [Detaching an Amazon EBS volume from a Linux instance](ebs-detaching-volume.md)\)\.
1. Create an AMI from your instance store\-backed instance by satisfying the prerequisites and following the procedures in [Creating an instance store\-backed Linux AMI](creating-an-ami-instance-store.md)\. When you are finished creating an AMI from your instance, return to this procedure\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-resize.md |
c6a516a42ec5-1 | 1. Open the Amazon EC2 console and in the navigation pane, choose **AMIs**\. From the filter lists, choose **Owned by me**, and choose the image that you created in the previous step\. Notice that **AMI Name** is the name that you specified when you registered the image and **Source** is your Amazon S3 bucket\.
**Note**
If you do not see the AMI that you created in the previous step, make sure that you have selected the Region in which you created your AMI\.
1. Choose **Launch**\. When you specify options for the instance, be sure to select the new instance type that you want\. If the instance type that you want can't be selected, then it is not compatible with configuration of the AMI that you created \(for example, because of virtualization type\)\. You can also specify any EBS volumes that you detached from the original instance\.
It can take a few minutes for the instance to enter the `running` state\.
1. \(Optional\) You can terminate the instance that you started with, if it's no longer needed\. Select the instance and verify that you are about to terminate the original instance, not the new instance \(for example, check the name or launch time\)\. Choose **Actions**, **Instance State**, **Terminate**\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-resize.md |
08b119e9eb2a-0 | If the current configuration of your instance is incompatible with the new instance type that you want, then you can't resize the instance to that instance type\. Instead, you can migrate your application to a new instance with a configuration that is compatible with the new instance type that you want\.
If you want to move from an instance launched from a PV AMI to an instance type that is HVM only, the general process is as follows:
**To migrate your application to a compatible instance**
1. Back up any data on your instance store volumes that you need to keep to persistent storage\. To migrate data on your EBS volumes that you need to keep, create a snapshot of the volumes \(see [Creating Amazon EBS snapshots](ebs-creating-snapshot.md)\) or detach the volume from the instance so that you can attach it to the new instance later \(see [Detaching an Amazon EBS volume from a Linux instance](ebs-detaching-volume.md)\)\.
1. Launch a new instance, selecting the following:
+ An HVM AMI\.
+ The HVM only instance type\.
+ If you are using an Elastic IP address, select the VPC that the original instance is currently running in\.
+ Any EBS volumes that you detached from the original instance and want to attach to the new instance, or new EBS volumes based on the snapshots that you created\.
+ If you want to allow the same traffic to reach the new instance, select the security group that is associated with the original instance\.
1. Install your application and any required software on the instance\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-resize.md |
08b119e9eb2a-1 | 1. Install your application and any required software on the instance\.
1. Restore any data that you backed up from the instance store volumes of the original instance\.
1. If you are using an Elastic IP address, assign it to the newly launched instance as follows:
1. In the navigation pane, choose **Elastic IPs**\.
1. Select the Elastic IP address that is associated with the original instance and choose **Actions**, **Disassociate address**\. When prompted for confirmation, choose **Disassociate address**\.
1. With the Elastic IP address still selected, choose **Actions**, **Associate address**\.
1. From **Instance**, select the new instance, and then choose **Associate**\.
1. \(Optional\) You can terminate the original instance if it's no longer needed\. Select the instance and verify that you are about to terminate the original instance, not the new instance \(for example, check the name or launch time\)\. Choose **Actions**, **Instance State**, **Terminate**\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/ec2-instance-resize.md |
8c14b766743a-0 | A Spot Instance is an unused EC2 instance that is available for less than the On\-Demand price\. Because Spot Instances enable you to request unused EC2 instances at steep discounts, you can lower your Amazon EC2 costs significantly\. The hourly price for a Spot Instance is called a Spot price\. The Spot price of each instance type in each Availability Zone is set by Amazon EC2, and is adjusted gradually based on the long\-term supply of and demand for Spot Instances\. Your Spot Instance runs whenever capacity is available and the maximum price per hour for your request exceeds the Spot price\.
Spot Instances are a cost\-effective choice if you can be flexible about when your applications run and if your applications can be interrupted\. For example, Spot Instances are well\-suited for data analysis, batch jobs, background processing, and optional tasks\. For more information, see [Amazon EC2 Spot Instances](https://aws.amazon.com/ec2/spot-instances/)\.
**Topics**
+ [Concepts](#spot-features)
+ [How to get started](#spot-get-started)
+ [Related services](#spot-related-services)
+ [Pricing and savings](#spot-pricing) | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/using-spot-instances.md |
e24eb5443559-0 | Before you get started with Spot Instances, you should be familiar with the following concepts:
+ *Spot Instance pool* – A set of unused EC2 instances with the same instance type \(for example, `m5.large`\), operating system, Availability Zone, and network platform\.
+ *Spot price* – The current price of a Spot Instance per hour\.
+ *Spot Instance request* – Requests a Spot Instance\. The request provides the maximum price per hour that you are willing to pay for a Spot Instance\. If you don't specify a maximum price, the default maximum price is the On\-Demand price\. When the maximum price per hour for your request exceeds the Spot price, Amazon EC2 fulfills your request if capacity is available\. A Spot Instance request is either *one\-time* or *persistent*\. Amazon EC2 automatically resubmits a persistent Spot Instance request after the Spot Instance associated with the request is terminated\. Your Spot Instance request can optionally specify a duration for the Spot Instances\.
+ *Spot Fleet* – A set of Spot Instances that is launched based on criteria that you specify\. The Spot Fleet selects the Spot Instance pools that meet your needs and launches Spot Instances to meet the target capacity for the fleet\. By default, Spot Fleets are set to *maintain* target capacity by launching replacement instances after Spot Instances in the fleet are terminated\. You can submit a Spot Fleet as a one\-time *request*, which does not persist after the instances have been terminated\. You can include On\-Demand Instance requests in a Spot Fleet request\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/using-spot-instances.md |
e24eb5443559-1 | + *Spot Instance interruption* – Amazon EC2 terminates, stops, or hibernates your Spot Instance when the Spot price exceeds the maximum price for your request or capacity is no longer available\. Amazon EC2 provides a Spot Instance interruption notice, which gives the instance a two\-minute warning before it is interrupted\. | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/using-spot-instances.md |
69d32e0eec05-0 | The following table lists the key differences between Spot Instances and On\-Demand Instances\.
| | Spot Instances | On\-Demand Instances |
| --- | --- | --- |
| Launch time | Can only be launched immediately if the Spot Request is active and capacity is available\. | Can only be launched immediately if you make a manual launch request and capacity is available\. |
| Available capacity | If capacity is not available, the Spot Request continues to automatically make the launch request until capacity becomes available\. | If capacity is not available when you make a launch request, you get an insufficient capacity error \(ICE\)\. |
| Hourly price | The hourly price for Spot Instances varies based on demand\. | The hourly price for On\-Demand Instances is static\. |
| Instance interruption | You can stop and start an Amazon EBS\-backed Spot Instance\. In addition, the Amazon EC2 Spot service can [interrupt](spot-interruptions.md) an individual Spot Instance if capacity is no longer available, the Spot price exceeds your maximum price, or demand for Spot Instances increases\. | You determine when an On\-Demand Instance is interrupted \(stopped, hibernated, or terminated\)\. | | https://github.com/siagholami/aws-documentation/tree/main/documents/amazon-ec2-user-guide/doc_source/using-spot-instances.md |
Subsets and Splits