# Amazon Corretto

Cloud service · AWS. Updated 2026-11-12. Page: https://blowstack.com/tools/cloud-services-hub/amazon-corretto

> Amazon Corretto is a no-cost, multiplatform, production-ready distribution of the Open Java Development Kit (OpenJDK) maintained by Amazon to ensure long-term support with performance and security updates.

## 7 key features of Amazon Corretto

Amazon Corretto is a no-cost, multiplatform OpenJDK distribution with long-term support that is certified as Java SE standard compliant, supports multiple platforms including Linux, Windows, macOS, and Docker, includes performance optimizations, integrates well with AWS, and receives regular security updates.

1. **No-Cost Distribution**: Amazon Corretto is a no-cost, multiplatform, production-ready distribution of the Open Java Development Kit (OpenJDK) that comes with long-term support.
2. **Long-Term Support (LTS)**: Amazon provides long-term support for Amazon Corretto, with updates and security patches. This support ensures that applications continue to run on a secure and stable platform.
3. **Certified Java SE Standard Compliant**: Corretto is certified as compatible with the Java SE standard, ensuring that it meets the standards and is interoperable with other Java implementations.
4. **Multiplatform Support**: Amazon Corretto supports multiple platforms, including Linux, Windows, macOS, and Docker, ensuring broad applicability and flexibility for development and deployment scenarios.
5. **Performance Optimization**: Amazon Corretto includes performance enhancements and optimizations over standard OpenJDK distributions. These enhancements result in higher efficiency and performance for Java applications.
6. **Amazon Web Services Integration**: Designed with a deep integration for AWS, Amazon Corretto is optimized for AWS workloads but remains an excellent choice for applications running on other platforms.
7. **Security Updates**: Amazon Corretto receives regular security updates to help mitigate vulnerabilities and protect applications against security threats.

## Where Amazon Corretto is used

Amazon Corretto is used for developing enterprise Java applications, cloud-native applications, microservices architectures, IoT and edge computing solutions, and gaming back-end services, offering a performance-optimized, stable, and secure platform with long-term support.

1. **Enterprise Java Applications**: Businesses can utilize Amazon Corretto for building and running Java-based enterprise applications with a performance-optimized, stable, and secure platform that is fully compatible with the Java SE standard. This ensures applications perform optimally on both cloud and on-premise environments, making it an ideal choice for enterprises seeking a reliable Java solution.
2. **Cloud-Native Applications**: Developers can leverage Amazon Corretto to develop and operate cloud-native applications that require the Java runtime. It ensures that these applications are running on a consistent and long-term supported platform, with the flexibility to deploy across various cloud services, benefiting from Corretto's regular updates and security patches.
3. **Microservices Architecture**: By adopting Amazon Corretto, organizations can implement microservices architectures with Java, taking advantage of Corretto's performance optimizations and scalability. This is vital for microservices that need to efficiently manage resources and ensure seamless operation under varying loads, providing an efficient way to develop and scale microservices independently.
4. **IoT and Edge Computing**: Amazon Corretto is suited for IoT applications and edge computing solutions, enabling developers to build, deploy, and manage Java applications that require a small footprint, fast execution, and long-term support. Corretto's efficiency and reliability make it a strong candidate for IoT devices and edge computing scenarios where resources are limited and stability is crucial.
5. **Gaming Back-End Services**: For gaming companies looking to develop stable, high-performance back-end services, Amazon Corretto offers a robust platform. Its consistent performance and support for Java allow developers to build reliable gaming back-ends that can handle the high throughput and low latency demands of modern multiplayer games, ensuring a smooth gaming experience.

## How Amazon Corretto is priced

Amazon Corretto is offered at no cost with open-source distribution and includes long-term support.

- **Free Distribution**: Amazon Corretto is an open-source, no-cost distribution of the Open Java Development Kit (OpenJDK) provided by Amazon. It includes long-term support at no additional cost.

## Services Amazon Corretto works with

- **[AWS Lambda](https://blowstack.com/tools/cloud-services-hub/aws-lambda)**: Amazon Corretto can be used as a runtime environment for Java-based AWS Lambda functions, enabling the deployment of serverless applications with a secure, stable, and high-performance JDK.
- **[Amazon Elastic Container Registry (Amazon ECR)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-container-registry-(amazon-ecr))**: Official Amazon Corretto container images are published in Amazon ECR Public. These images provide a ready-to-use Java environment and can serve as base images for containerized Java applications.
- **[Amazon EMR](https://blowstack.com/tools/cloud-services-hub/amazon-emr)**: Amazon Corretto supplies Java runtimes in Amazon EMR releases for JVM-based big-data applications. The available and default Corretto versions depend on the EMR release and application, allowing workloads such as Spark jobs to use the supported Java environment.
- **[Amazon Managed Service for Apache Flink](https://blowstack.com/tools/cloud-services-hub/amazon-managed-service-for-apache-flink)**: Amazon Corretto supplies the Java runtime used by supported Amazon Managed Service for Apache Flink runtime versions. Java and Scala Flink applications execute on this managed JVM, with the Java version determined by the selected Flink runtime.
- **[Amazon CodeGuru](https://blowstack.com/tools/cloud-services-hub/amazon-codeguru)**: Amazon Corretto applications can use the Amazon CodeGuru Profiler Java agent to collect runtime profiles. These profiles help identify CPU-intensive methods and other performance bottlenecks in a running Java application.
- **[AWS App Runner](https://blowstack.com/tools/cloud-services-hub/aws-app-runner)**: Amazon Corretto powers AWS App Runner’s managed Java runtimes for source-code deployments. Selecting a supported Java runtime lets App Runner build and run a Java web application without requiring a custom container image.
- **[AWS CodeBuild](https://blowstack.com/tools/cloud-services-hub/aws-codebuild)**: Amazon Corretto is available as a Java runtime in AWS CodeBuild’s managed build images. A buildspec can select a supported Corretto version to compile Java source code, run tests, and package application artifacts.
- **[AWS Elastic Beanstalk](https://blowstack.com/tools/cloud-services-hub/aws-elastic-beanstalk)**: Amazon Corretto powers AWS Elastic Beanstalk’s Java SE and Tomcat platform branches. These platforms deploy Java applications with a managed Corretto runtime, and platform updates deliver runtime fixes alongside other platform components.
- **[AWS Glue](https://blowstack.com/tools/cloud-services-hub/aws-glue)**: Amazon Corretto provides the JVM in AWS Glue environments, including its published Spark development container images. This allows Java-based Spark components and local Glue development workloads to run with the Java version supplied for that Glue release.
- **[AWS IoT Greengrass](https://blowstack.com/tools/cloud-services-hub/aws-iot-greengrass)**: Amazon Corretto can supply the Java runtime required by the AWS IoT Greengrass nucleus on a core device. Installing a supported Corretto version enables the nucleus to run and manage Greengrass components on that device.
- **[AWS Schema Conversion Tool (AWS SCT)](https://blowstack.com/tools/cloud-services-hub/aws-schema-conversion-tool-(aws-sct))**: Amazon Corretto provides the Java runtime used by AWS Schema Conversion Tool. This runtime supports running the desktop tool for database schema assessment and conversion.

## What is Amazon Corretto

Amazon Corretto is a no-cost, multiplatform, production-ready distribution of the Open Java Development Kit (OpenJDK). OpenJDK serves as the open-source implementation of the Java Platform, Standard Edition (SE), and Amazon Corretto provides a long-term support (LTS) offering that includes performance enhancements and security fixes. Created and maintained by Amazon Web Services (AWS), Corretto is designed to ensure that Java applications run smoothly with consistent performance and reliability on platforms ranging from desktops and servers to cloud environments.

One of the key attributes of Amazon Corretto is its commitment to long-term support. Support periods vary by release: Corretto 25 is a long-term support (LTS) release with end of life in October 2032, while Corretto 27 is a Feature Release (FR) with end of life in April 2027. This is particularly appealing for enterprises and developers who need a stable and secure Java environment without worrying about abrupt changes or the need for frequent migrations. By providing a dependable runtime, Amazon Corretto effectively addresses one of the major concerns with open-source software: the uncertainty regarding the lifecycle and support of the product.

Amazon Corretto is designed to be compatible with Java SE standard, making it an easy substitute for other JDKs in almost any Java application. Its compatibility means that developers can switch their applications to Corretto with confidence, knowing their applications will continue to function as expected.

Moreover, AWS actively participates in the OpenJDK community, contributing patches and enhancements back to the OpenJDK project, thus ensuring Corretto is up-to-date with the latest in Java technology. Another significant advantage of Amazon Corretto is its platform independence. It is available for multiple platforms, including Linux, Windows, macOS, and Docker, allowing developers to leverage its robustness across various operating systems and cloud infrastructures. This multiplatform support ensures that businesses can use Corretto in their diverse IT ecosystems without compatibility issues. Performance is also a hallmark of Amazon Corretto.

AWS has optimized Corretto for high-performance, large-scale Java applications. It includes performance enhancements that are not found in other distributions of OpenJDK, which can lead to better application efficiency and user experience. These enhancements are particularly beneficial in cloud and enterprise environments where resources and scalability are critical considerations.

To sum up, Amazon Corretto offers a reliable and cost-effective Java platform that blends the quality assurance of long-term support with the innovation and flexibility inherent in the open-source model. It addresses the needs of developers and businesses for a stable, scalable, and high-performance Java runtime that is compatible across multiple platforms. By providing long-term support, performance optimizations, and actively contributing to the OpenJDK community, Amazon Corretto stands out as a strategic choice for developers and enterprises leveraging Java in their software solutions.
