Should you’re a Java software program developer and you were not dwelling on the planet Mars throughout these final years, you then actually know what Quarkus is. And simply in case you do not, you could discover it out right here.
With Quarkus, the sphere of enterprise cloud-native functions growth has by no means been so comfy and it by no means took benefit of such a pleasant {and professional} working surroundings. The Web abounds with posts and articles explaining why and the way Quarkus is a should for the enterprise, cloud-native software program developer. And naturally, CDK functions aren’t on the sidelines: on the other, they will tremendously make the most of the Quarkus options to turn out to be smaller, sooner, and extra aligned with necessities these days.
CDK With Quarkus
Let’s take a look at our first CDK with Quarkus instance within the code repository. Go to the Maven module named cdk-quarkus and open the file pom.xml to see tips on how to mix particular CDK and Quarkus dependencies and plugins.
...
io.quarkus.platform
quarkus-bom
${quarkus.platform.model}
pom
import
io.quarkiverse.amazonservices
quarkus-amazon-services-bom
${quarkus-amazon-services.model}
pom
import
...
Along with the aws-cdk-lib artifact which represents the CDK API library and is inherited from the mother or father Maven module, the dependencies above are required so as to develop CDK Quarkus functions. The primary one, quarkus-bom, is the Invoice of Materials (BOM) which incorporates all the opposite required Quarkus artifacts. Right here, we’re utilizing Quarkus 3.11 which is the newest launch as of this writing. The second is the BOM of the Quarkus extensions required to work together with AWS providers.
One other necessary requirement of Quarkus functions is using the quarkus-maven-plugin which is accountable for operating the construct and augmentation course of. Let’s recall that versus extra conventional frameworks like Spring or Jakarta EE the place the applying’s initialization and configuration steps occur on the runtime, Quarkus performs them at construct time, in a particular part known as “augmentation.” Consequently, Quarkus does not depend on Java introspection and reflection, which is without doubt one of the causes it’s a lot sooner than Spring, however wants to make use of the jandex-maven-plugin to construct an index serving to to find annotated courses and beans in exterior modules.
That is nearly all so far as the Quarkus grasp POM is worried. Let’s look now on the CDK submodule. However first, we have to recall that, so as to synthesize and deploy a CDK software, we’d like a particular working surroundings outlined by the cdk.json file. Therefore, attempting to make use of CDK instructions in a undertaking not having at its root this file will fail.
One of many important features of the cdk.json file goals to outline tips on how to run the CDK software. By default, the cdk init app --language java command, used to scaffold the undertaking’s skeleton, will generate the next JSON assertion:
...
"app": "mvn -e -q compile exec:java"
...
Which means that each time we run a cdk deploy ... command, such that to synthesize a CloudFormation stack and deploy it, the maven-exec-plugin shall be used to compile and package deal the code, earlier than beginning the related major Java class. That is essentially the most normal case, the one in all a classical Java CDK software. However to run a Quarkus software, we have to observe some particular situations.
Quarkus packages an software as both a quick or a skinny JAR and, if you happen to aren’t aware of these phrases, please do not hesitate to seek the advice of the documentation which explains them intimately. What pursuits us right here is the truth that, by default, a quick JAR shall be generated, underneath the identify of quarkus-run.jar within the goal/quarkus-app listing. Until we’re utilizing Quarkus extensions for AWS, by which case a skinny JAR is generated, in goal/$finalName-runner.jar file, the place $finalName is the worth of the identical aspect in pom.xml.
In our case, we’re utilizing Quarkus extensions for AWS and, therefore, a skinny JAR shall be created by the Maven construct course of. In an effort to run a Quarkus skinny JAR, we have to manually modify the cdk.json file to switch the road above with the next one:
...
"app": "java -jar target/quarkus-app/quarkus-run.jar"
...
The opposite vital level to note right here is that, normally, a Quarkus software is exposing a REST API whose endpoint is began by the command above. However in our case, the one in all a CDK software, there is no REST API and, therefore, this endpoint must be specified another way. Have a look at our major class within the cdk-quarkus-api-gatewaymodule.
@QuarkusMain
public class CdkApiGatewayMain
{
public static void major(String... args)
{
Quarkus.run(CdkApiGatewayApp.class, args);
}
}
Right here, the @QuarkusMain annotation flags the next class as the applying’s major endpoint and, additional, utilizing the io.quarkus.runtime.Quarkus.run() methodology will execute the talked about class till it receives a sign like Ctrl-C, or one of many exit strategies of the identical API is known as.
So, we simply noticed how the CDK Quarkus software is began and that, as soon as began, it runs the CdkApiGAtewayApp till it exits. This class is our CDK one which implements the App and that we have already seen within the earlier put up. However this time it seems to be otherwise, as you might even see:
@ApplicationScoped
public class CdkApiGatewayApp implements QuarkusApplication
{
personal CdkApiGatewayStack cdkApiGatewayStack;
personal App app;
@Inject
public CdkApiGatewayApp (App app, CdkApiGatewayStack cdkApiGatewayStack)
{
this.app = app;
this.cdkApiGatewayStack = cdkApiGatewayStack;
}
@Override
public int run(String... args) throws Exception
{
Tags.of(app).add("project", "API Gateway with Quarkus");
Tags.of(app).add("environment", "development");
Tags.of(app).add("application", "CdkApiGatewayApp");
cdkApiGatewayStack.initStack();
app.synth();
return 0;
}
}The very first thing to note is that this time, we’re utilizing the CDI (Context and Dependency Injection) carried out by Quarkus, additionally known as ArC, which is a subset of the Jakarta CDI 4.1 specs. It additionally has one other particularity: it is a build-time CDI, versus the runtime Jakarta EE one. The distinction lies within the augmentation course of, as defined beforehand.
One other vital level to watch is that the category implements the io.quarkus.runtime.QuarkusApplication interface which permits it to customise and carry out particular actions within the context bootstrapped by the CdkApiGatewayMain class. As a matter of truth, it is not really useful to carry out such operations immediately within the CdkApiGatewayMain since, at that time, Quarkus is not utterly bootstrapped and began but.
We have to outline our class as @ApplicationScoped, such that to be instantiated solely as soon as. We additionally used constructor injection and took benefit of the producer sample, as you might even see within the CdkApiGatewayProducer class. We override the io.quarkus.runtime.QuarkusApplication.run() methodology such that to customise our App object by tagging it, as we already did within the earlier instance, and to invoke CdkApiGatewayStack, accountable to instantiate and initialize our CloudFormation stack. Final however not least, the app.synth() assertion is synthesizing this stack and, as soon as executed, our infrastructure, as outlined by the CdkApiGatewayStack, needs to be deployed on the AWS cloud.
Right here is now the CdkApiGatewayStack class:
@Singleton
public class CdkApiGatewayStack extends Stack
{
@Inject
LambdaWithBucketConstructConfig config;
@ConfigProperty(identify = "cdk.lambda-with-bucket-construct-id", defaultValue = "LambdaWithBucketConstructId")
String lambdaWithBucketConstructId;
@Inject
public CdkApiGatewayStack(closing App scope,
closing @ConfigProperty(identify = "cdk.stack-id", defaultValue = "QuarkusApiGatewayStack") String stackId,
closing StackProps props)
{
tremendous(scope, stackId, props);
}
public void initStack()
{
String functionUrl = new LambdaWithBucketConstruct(this, lambdaWithBucketConstructId, config).getFunctionUrl();
CfnOutput.Builder.create(this, "FunctionURLOutput").worth(functionUrl).construct();
}
}
This class has modified as effectively, in comparison with its earlier launch. It is a singleton that makes use of the idea of assemble, which was launched previously. As a matter of truth, as an alternative of defining the stack construction right here, on this class, as we did earlier than, we do it by encapsulating the stack’s parts along with their configuration in a assemble that facilitates simply assembled cloud functions. In our undertaking, this assemble is part of a separate module, named cdk-simple-construct, such that we might reuse it repeatedly and enhance the applying’s modularity.
public class LambdaWithBucketConstruct extends Assemble
{
personal FunctionUrl functionUrl;
public LambdaWithBucketConstruct(closing Assemble scope, closing String id, LambdaWithBucketConstructConfig config)
{
tremendous(scope, id);
Function function = Function.Builder.create(this, config.functionProps().id() + "-role")
.assumedBy(new ServicePrincipal("lambda.amazonaws.com")).construct();
function.addManagedPolicy(ManagedPolicy.fromAwsManagedPolicyName("AmazonS3FullAccess"));
function.addManagedPolicy(ManagedPolicy.fromAwsManagedPolicyName("CloudWatchFullAccess"));
IFunction operate = Operate.Builder.create(this, config.functionProps().id())
.runtime(Runtime.JAVA_21)
.function(function)
.handler(config.functionProps().handler())
.memorySize(config.functionProps().ram())
.timeout(Period.seconds(config.functionProps().timeout()))
.functionName(config.functionProps().operate())
.code(Code.fromAsset((String) this.getNode().tryGetContext("zip")))
.construct();
functionUrl = operate.addFunctionUrl(FunctionUrlOptions.builder().authType(FunctionUrlAuthType.NONE).construct());
new Bucket(this, config.bucketProps().bucketId(), BucketProps.builder().bucketName(config.bucketProps().bucketName()).construct());
}
public String getFunctionUrl()
{
return functionUrl.getUrl();
}
}
That is our assemble which encapsulates our stack parts: a Lambda operate with its related IAM function and an S3 bucket. As you’ll be able to see, it extends the software program.assemble.Assemble class and its constructor, along with the usual scopeand id, parameters take a configuration object named LambdaWithBucketConstructConfig which defines, amongst others, properties associated to the Lambda operate and the S3 bucket belonging to the stack.
Please discover that the Lambda operate wants the IAM-managed coverage AmazonS3FullAccess so as to learn, write, delete, and so on. to/from the related S3 bucket. And since for tracing functions, we have to log messages to the CloudWatch service, the IAM-managed coverage CloudWatchFullAccess is required as effectively. These two insurance policies are related to a task whose naming conference consists of appending the suffix -role to the Lambda operate identify. As soon as this function is created, it will likely be hooked up to the Lambda operate.
As for the Lambda operate physique, please discover how that is created from an asset dynamically extracted from the deployment context. We’ll come again in a number of moments with extra particulars regarding this level.
Final however not least, please discover how after the Lambda operate is created, a URL is hooked up to it and cached such that it may be retrieved by the buyer. This fashion we utterly decouple the infrastructure logic (i.e., the Lambda operate itself) from the enterprise logic; i.e., the Java code executed by the Lambda operate, in our case, a REST API carried out as a Quarkus JAX-RS (RESTeasy) endpoint, performing as a proxy for the API Gateway uncovered by AWS.
Coming again to the CdkApiGatewayStack class, we will see how on behalf of the Quarkus CDI implementation, we inject the configuration object LambdaWithBucketConstructConfig declared externally, in addition to how we use the Eclipse MicroProfile Configuration to outline its ID. As soon as the LambdaWithBucketConstruct instantiated, the one factor left to do is to show the Lambda operate URL such that we will name it with totally different shoppers, whether or not JUnit integration assessments, curl utility, or postman.
We simply have seen the entire mechanics which permits us to decouple the 2 basic CDK constructing blocks App and Stack. We even have seen tips on how to summary the Stack constructing block by making it an exterior module which, as soon as compiled and constructed as a standalone artifact, can merely be injected wherever wanted. Moreover, we’ve got seen the code executed by the Lambda operate in our stack will be plugged in as effectively by offering it as an asset, within the type of a ZIP file, for instance, and saved within the CDK deployment context. This code is, too, an exterior module named quarkus-api and consists of a REST API having a few endpoints permitting us to get some info, just like the host IP tackle or the S3 bucket’s related attributes.
It is attention-grabbing to note how Quarkus takes benefit of the Qute templates to render HTML pages. For instance, the next endpoint shows the attributes of the S3 bucket that has been created as part of the stack.
...
@Inject
Template s3Info;
@Inject
S3Client s3;
...
@GET
@Path("info/{bucketName}")
@Produces(MediaType.TEXT_HTML)
public TemplateInstance getBucketInfo(@PathParam("bucketName") String bucketName)
{
Bucket bucket = s3.listBuckets().buckets().stream().filter(b -> b.identify().equals(bucketName))
.findFirst().orElseThrow();
TemplateInstance templateInstance = s3Info.information("bucketName", bucketName, "awsRegionName",
s3.getBucketLocation(GetBucketLocationRequest.builder().bucket(bucketName).construct())
.locationConstraintAsString(),
"arn", String.format(S3_FMT, bucketName), "creationDate",
LocalDateTime.ofInstant(bucket.creationDate(), ZoneId.systemDefault()), "versioning",
s3.getBucketVersioning(GetBucketVersioningRequest.builder().bucket(bucketName).construct()));
return templateInstance.information("tags",
s3.getBucketTagging(GetBucketTaggingRequest.builder().bucket(bucketName).construct()).tagSet());
}
This endpoint returns a TemplateInstance whose construction is outlined within the file src/major/assets/templates/s3info.htmland which is crammed with information retrieved by interrogating the S3 bucket in our stack, on behalf of the S3Client class offered by the AWS SDK.
A few integration assessments are offered and so they make the most of the Quarkus integration with AWS, due to which it’s doable to run native cloud providers, on behalf of testcontainers and localstack. In an effort to run them, proceed as follows:
$ git clone https://github.com/nicolasduminil/cdk
$ cd cdk/cdk-quarkus/quarkus-api
$ mvn confirm
Operating the sequence of instructions above will produce a fairly verbose output and, on the finish, you will see one thing like this:
[INFO]
[INFO] Outcomes:
[INFO]
[INFO] Assessments run: 3, Failures: 0, Errors: 0, Skipped: 0
[INFO]
[INFO]
[INFO] --- failsafe:3.2.5:confirm (default) @ quarkus-api ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Complete time: 22.344 s
[INFO] Completed at: 2024-07-04T17:18:47+02:00
[INFO] ------------------------------------------------------------------------That is not a giant deal – simply a few integration assessments executed in opposition to a localstack operating in testcontainers to ensure that all the pieces works as anticipated. However if you wish to check in opposition to actual AWS providers, which means that you simply fulfill the necessities, then it is best to proceed as follows:
$ git clone https://github.com/nicolasduminil/cdk
$ cd cdk
$ ./deploy.sh cdk-quarkus/cdk-quarkus-api-gateway cdk-quarkus/quarkus-api/
Operating the script deploy.sh with the parameters proven above will synthesize and deploy your stack. These two parameters are:
- The CDK software module identify: That is the identify of the Maven module the place your
cdk.jsonfile is. - The REST API module identify: That is the identify of the Maven module the place the
operate.zipfile is.
Should you take a look at the deploy.sh file, you will see the next:
...cdk deploy --all --context zip=~/cdk/$API_MODULE_NAME/goal/operate.zip...This command deploys the CDK app after having set within the zip context variable the operate.zip location. Do you keep in mind that the Lambda operate has been created within the stack (LambdaWithBucketConstruct class) like this?
IFunction operate = Operate.Builder.create(this, config.functionProps().id())
...
.code(Code.fromAsset((String) this.getNode().tryGetContext("zip")))
.construct();
The assertion beneath will get the asset saved within the deployment context underneath the context variable zip and makes use of it because the code that shall be executed by the Lambda operate.
The output of the deploy.sh file execution (fairly verbose as effectively) will end by displaying the Lambda operate URL:
...
Outputs:
QuarkusApiGatewayStack.FunctionURLOutput = https://...lambda-url.eu-west-3.on.aws/
Stack ARN:
arn:aws:cloudformation:eu-west-3:...:stack/QuarkusApiGatewayStack/...
...Now, so as to check your stack, you could hearth your most well-liked browser at
https://
Conclusion
Your check is profitable and also you now know tips on how to use CDK constructs to create infrastructure standalone modules and assemble them into AWS CloudFormation stacks. However there’s extra, so keep tuned!