Before you begin

1. To build an architecture, you must have familiarity with Terraform.

2. Verify that you're using a Pay-As-You-Go or Subscription account by going to Manage > Account > Account settings in the IBM Cloud console.

3. Create a repository to store your deployable architecture. For the purposes of this tutorial, GitHub is used. For more information, see Create a repo.

4. Install an editor of your choice, for example, Visual Studio Code.

5. Verify that you're assigned the following IBM Cloud Identity and Access Management (IAM) roles:

   • Administrator on All IAM Account Management services, All Account Management services, and All Identity and Access enabled services.
   • Editor on the Catalog Management service.
   • Manager service access role for Schematics.
   • Other roles that are required for specific resources in your deployable architecture. Cloud automation for Code Engine requires the Writer service access role that is scoped to all resources for the Code Engine service.

   For more information, go to Assigning access to account management services and Managing access to resources.

Downloading the deployable architecture files

To begin, you need to download the deployable architecture files. The files include a main.tf file that invokes the root Terraform module.

1. In the IBM Cloud console, click Catalog.

2. Enter Cloud automation for Code Engine into the search bar and select the architecture from the list of search results.

3. Select v4.2.2 as the product version.

   This tutorial was created based on version 4.2.2 of Cloud automation for Code Engine. However, you can select another version of the deployable architecture if you want to.

4. Make sure the New Code Engine apps variation is selected.

5. Click Review deployment options from the summary panel.

6. Select Work with code > Download bundle to download the bundle.

7. Open the downloaded bundle on your local computer.

8. Extract the .tar.gz bundle to access and edit the files within a folder. Renamed the extracted folder Example-corp-infrastructure for findability and ease-of-use.

   After successfully downloading and extracting the bundle, you'll see the following files and folders:

   • automation folder
   • ibm_catalog.json
   • main.tf
   • outputs.tf
   • provider.tf
   • README.md
   • variables.tf
   • version.tf

Editing your list of variables

When your infrastructure architect researched IBM Cloud Code Engine, they decided to modify the region and IBM Cloud API key. The other variables that are included in the architecture aren't needed for your purposes, and so you need to remove them by using your favorite editor Visual Studio Code.

1. In Visual Studio Code, open the variables.tf file.

2. Move the following variables to the start of the variables.tf file.

   • ibmcloud_api_key
   • prefix
   • existing_resource_group_name
   • region

   The order of the variables does not matter.

3. Delete all the other variables and save the file.

Updating the main.tf file

Now that you updated the variables.tf file, make sure that the configuration information in the main.tf file is correct. Since you want to use Code Engine to run an application that Example Corp created, you need to provide information about your application.

1. Open the main.tf file.

2. Update the app_name variable and enter "example-corp-ai-app" as the name of the application.

3. Update the image_reference variable and enter "icr.io/codeengine/helloworld", which is the docker image for your application.

4. Add the project_name variable and enter "example-corp-ce-project" as the name for your Code Engine project.

5. Add the provider_visibility variable and set it to "public".

6. Confirm that the ibmcloud_api_key, prefix, and region variables are included as shown in the following example:

   module "deploy-arch-ibm-code-engine" {
     source      = "https://cm.globalcatalog.cloud.ibm.com/api/v1-beta/offering/source/archive//solutions/apps?archive=tgz&catalogID=7a4d68b4-cf8b-40cd-a3d1-f49aff526eb3&flavor=apps&installType=fullstack&kind=terraform&name=deploy-arch-ibm-code-engine&version=v4.2.2"
     ibmcloud_api_key      = var.ibmcloud_api_key
     prefix      = var.prefix
     existing_resource_group_name      = var.existing_resource_group_name
     region      = var.region
     app_name      = "example-corp-ai-app"
     image_reference      = "icr.io/codeengine/helloworld"
     project_name      = "example-corp-ce-project"
     provider_visibility      = "public"
   }
   

7. Save the file.

Your architecture is now hardcoded to reference your Example Corp AI app and configured to use the variables for IBM Cloud API key, prefix, and region.

Updating the ibm_catalog.json file

The ibm_catalog.json file is a manifest JSON file that is used to automatically import version information when you onboard a deployable architecture to a private catalog. Because you changed the deployable architecture, you created a brand-new architecture for your needs. Update the following information in the ibm_catalog.json file to reflect your changes.

For more information on the manifest file and what it contains, see Locally editing the catalog manifest.

Testing your deployable architecture

Before you onboard your configured deployable architecture to a private catalog and make it available for use, test your configuration to help ensure that the architecture runs as intended. To test your architecture with the Terraform command line, complete the following steps:

1. Create or update a .netrc file that is needed to use Terraform modules from IBM Cloud. For more information, see ibmcloud catalog utility netrc.

   ibmcloud catalog utility netrc
   

2. Initialize the Terraform CLI. For more information, see Initializing Working Directories.

   terraform init
   

3. Provision the resources. For more information, see Provisioning Infrastructure with Terraform.

   1. Run terraform plan to generate a Terraform execution plan to preview the proposed actions.

      terraform plan
      

   2. Run terraform apply to create the resources that are defined in the plan.

      terraform apply
      

Next steps

If your deployable architecture ran as expected, you successfully created your own deployable architecture from Cloud automation for Code Engine. You are now ready to move your updated files to the GitHub repository that you created and onboard your product to a private catalog.

After you onboard Example Corp's infrastructure to a private catalog, you can share it with your enterprise. If you're not ready to share your deployable architecture, or you're not a part of an enterprise, you can skip sharing it and continue on to the next tutorial, deploying Example Corp's infrastructure by using a project.