In this video, you’ll see how to increase application visibility and governance using AWS Service Catalog AppRegistry.
With this feature, you can create an application repository with associated resources,
define and manage your application metadata, and group applications by specific attributes.
To get started, let’s navigate to Service Catalog to create an AppRegistry application.
AppRegistry lets you natively build an AWS resources inventory,
allowing you to understand the context of your applications and resources across your environments.
AppRegistry apps and associations can be created and managed in several different ways.
To begin, we’ll use the AWS console.
An AppRegistry application can be associated with provisioned Service Catalog products or a CloudFormation stack ARN.
For the purposes of this example, we have two CloudFormation stacks already set up for a sample back end, so we’ll provide their ARNs.
By creating this app, we’re hoping to gain insight into our running services’ metadata
and define their relation to other resources in our organization.
Now that we’ve defined the CloudFormation stacks to be associated with our application, we can define attribute groups for it.
Attribute groups can be shared among different AppRegistry apps, unlike resources, which can only be mapped to one AppRegistry app each.
Attribute groups provide metadata and relational information among different resources and environments in an account.
We’ll define a new attribute group that specifies information about our “Operations” CloudFormation stack.
Attribute groups consist of JSON text data provided by the creator of the group.
When the attribute group is updated, it applies to every application associated with the group.
Tags can be added to apps and attribute groups to further organize and manage information.
For our purposes, let’s finish creating the application.
We can see the resources that define the AppRegistry application on the Resources tab.
Let’s take a quick look at the attribute group we created.
Now that we’ve seen how to create an application using the console interface,
let's see how to add an attribute group to an existing application.
This group will be for our “Core Services” CloudFormation stack.
Again, we’ll provide JSON text to specify the stack’s metadata schema.
Assigning an attribute group to an application in the AppRegistry is optional.
We’ll assign this attribute group to the app we created so we have both of our CloudFormation stacks covered.
After creating the attribute group, we’re taken to its page,
where we can see the JSON metadata we provided and any tags the group might have.
Let’s make sure this attribute group is associated with the application we created.
The second attribute group is now associated with our app.
Next, let’s create AppRegistry applications and associations using the AWS Command Line Interface (CLI).
We’ll use Cloud9 to simulate a local environment.
For the purposes of this example, we’ll run a script that automates the process we saw in the AWS console
and displays the CLI input and output of each successive command.
First, our script reads and prints out the JSON metadata corresponding to our “Operations” CloudFormation stack.
Next, our script creates the Operations attribute group.
Next, our script repeats the process to create the Core Services stack and attribute group.
Next, we create the actual AppRegistry application in Service Catalog, with the name my-app-cli.
Now we associate the two attribute groups with the new application.
Now, we associate both CloudFormation stacks with the application.
A third way to create Service Catalog AppRegistry applications and attribute groupings is through the AWS SDK.
Let’s look at an example Python application that performs the same actions we’ve seen in the AWS console and CLI.
First, we can see that the Boto3 Python package installed and imported our script.
Note that only Python 3.6 and above is currently supported.
This Python script calls Service Catalog programmatically through the Boto3 client.
We first create the AppRegistry application.
Next, we create the Core Services and Operations attribute groups and associate them with the application.
Finally, we associate our CloudFormation resources with the application.
The Python script has completed execution without errors.
Let’s check the AppRegistry console for updates.
As you can see, both the CLI workflow and the Python script using the AWS SDK successfully created applications in our account.
Let’s take a closer look at them.
As expected, the resource associations and attribute groups were successfully created by each method.
Finally, let’s take a look at a CloudFormation template we can use as a fourth method of deploying AppRegistry applications and attribute groups.
This YAML file defines a CloudFormation template that, when deployed, provisions the same set of AppRegistry resources we saw before.
The template deploys two attribute groups, two resource associations, and the AppRegistry app.
Let’s use it to create a stack.
Now that we’ve created the stack, let’s see what was deployed.
As you can see, the application and corresponding resource associations and attribute groups have been created successfully.
Lastly, let's return to our Applications to see the integration between AppRegistry and Systems Manager Applications Manager.
With Application Manager, you can view any operational metrics and alarms that you may have running for your application,
remediate potential issues with runbooks, and manage any necessary work items for your application.
You’ve just seen how to increase application visibility and governance using AWS Service Catalog AppRegistry.
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.