In this video, you’ll see how to accelerate modernization using
AWS Proton and Refactor Spaces.
With this solution, you can simplify the creation of refactoring environments,
helping teams create a scalable platform that provides self-service
capabilities to developers.
To get started, let’s navigate to AWS Migration Hub and open Refactor Spaces.
Refactor Spaces is the starting point for incremental application
refactoring to microservices in AWS.
Let’s create an environment.
A refactor environment is a container for all the services and proxies that
will be created for an application.
Let’s give this environment a name.
Next, we’ll create an application, which we'll use to manage our existing application,
add new services, and incrementally route traffic to the new services.
Let’s name our application “unistore.”
Next, we’ll select the application’s proxy VPC.
The proxy lets the front-end application use a single endpoint to contact multiple services.
If an application is made up of multiple AWS accounts, we can share the
refractor environment and its application with other AWS principals.
We’re going to create everything in a single account, so let’s move
on and create the environment.
Now that our environment has been created, let’s create a new service.
We’ll select the environment and application we just created.
Let’s name this service “legacy.”
Next, we’ll select the VPC where the service resides, and then specify the endpoint.
We’ll also specify the optional health check endpoint.
Next, we’ll set this service as the default route for the application and create the service.
The service and route have been successfully submitted and are being provisioned.
As shown in this diagram, Refactor Spaces will provision the infrastructure
with our Amazon API Gateway, Network Load Balancer, and AWS Transit Gateway,
and all traffic will be routed to our application.
Now let’s navigate to AWS Proton to create a microservice.
AWS Proton is a fully managed delivery service for deploying container and
serverless applications efficiently and consistently.
First, let’s create an environment template.
In this case, we’ll create a template for provisioning new environments.
Let’s enter a name and display name, and then create the template.
Now that we’ve created the environment template, let’s publish it so that it’s
visible to our developer teams.
The tooltip at the top of the screen gives us the option to create a service template.
Let’s do that now.
In this case, we’ll use a sample template bundle as our source.
Next, we’ll provide a name and display name for the template.
Let’s choose the environment template that we created earlier
and create the service template.
Now let’s see how to create a Proton environment using our environment template.
We can choose AWS-managed provisioning or self-managed provisioning.
In this case, we’ll choose the first option.
For simplicity, we’ll use the same AWS account.
Let’s name the environment.
Next, we’ll choose an existing service role in our account.
We can configure custom settings.
In this case, we’ll leave the default values.
Now let’s create the environment.
The deployment has succeeded.
Now let’s create a service.
We’ll use the service template we created earlier.
Let’s name the service.
Next, let’s choose a repository connection.
For demonstration purposes, we’ll select a CodeStar connection
that has already been created.
Next, we’ll choose a repository and a branch.
Next, let’s provide a name and environment for the new service instance.
We can add up to nine instances.
This diagram shows how AWS Proton deploys the service.
Let’s deploy it now.
The service is now active and the pipeline has been provisioned.
The pipeline run is in progress.
We can also see that the service instance has a deployment status of Succeeded.
Let’s navigate to the service instance.
We’ll copy the service endpoint so we can use it to point this service
to a microservice in Refactor Spaces.
Now let’s navigate to Refactor Spaces to create a service.
We’ll select the environment and application we created earlier.
Next, we’ll name the service.
Let’s select the new VPC we created and paste in the service endpoint we copied earlier.
Next, we’ll enter a source path to the route.
We can choose to include all child paths.
In this case, we’ll just start with GET.
Now let’s create the service.
Our service has been created.
Once the route finishes provisioning, we can use it to send traffic to the service.
You’ve just seen how to accelerate modernization using AWS Proton
and Refactor Spaces.
You can learn more about this topic in the description and links for this video.
Thanks for watching. Now it’s your turn to try.