vania-janet/multiturn-rag-retrieval-data huggingface dataset:
Schematics Blueprints is a [beta feature](https://cloud.ibm.com/docs/schematics?topic=schematics-bp-beta-limitations) that are available for evaluation and testing purposes. It is not intended for production usage. Refer to the list of [limitations](https://cloud.ibm.com/docs/schematics?topic=schematics-bp-beta-limitationssc-bp-beta-limitation) for the beta release.



 Reuse and customization 

IBM Cloud® Schematics Blueprints utilizes the analogy of building a house from a blueprint drawing. Where a blueprint defines the architecture, layout, major building blocks and customizations to be applied.

This building analogy also applies to reuse across environments. A builder may build an entire street of houses from the same blueprint drawing. Each house customized by its choice of color, lighting and styling, but all built to the same design.

Blueprint template reuse supports a number of use cases:



* Sharing an approved architecture across teams within a business
* Deploying instances across multiple regions to create a highly resilient application deployment
* Software delivery pipelines, dev, stage, prod





 Reuse across environments 

A blueprint template (house design) is reusable across environments, using a separately maintained [input configuration](https://cloud.ibm.com/docs/schematics?topic=schematics-sch-termsbpi1) to define the customizations for the target environment and usage. The figure illustrates this with deploying dev, stage and prod environments.

Zoom

![Environments deployed from reusable blueprint template](https://cloud.ibm.com/docs-content/v1/content/ba89e173287b28d1453d2a327d8a1f74ae2f1662/schematics//images/new/bp-reuse.svg)

Environments deployed from reusable blueprint template

A common reusable template defines the architecture, with separate input files for the dev, stage and prod for define the customizations.
curl -X GET https://schematics.cloud.ibm.com/v1/workspaces/ -H 'authorization: <auth> -H 'cache-control: no-cache'
3. Run [workspace upload](https://cloud.ibm.com/docs/schematics?topic=schematics-schematics-cli-referenceschematics-workspace-upload) to upload a agent-infrastructure-templates.tar file that contains the blueprint template, inputs details.

curl -X PUT https://schematics.cloud.ibm.com/v1/workspaces/{w_id}/template_data/{template_id}/template_repo_upload -H 'authorization: <auth> -H 'cache-control: no-cache' -H 'content-type: multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW' -F file=@agent-infrastructure-templates.tar
4. Run [workspace get](https://cloud.ibm.com/apidocs/schematics/schematicsget-workspace) command to pull the workspace details that are uploaded by the agent-infrastructure-templates.tar file.

curl -X GET https://schematics.cloud.ibm.com/v1/workspaces/{w_id} -H 'authorization: <auth> ' -H 'cache-control: no-cache' -H 'content-type: application/json'

Wait 45 - 90 minutes to provision the resource.
5. Run [apply command](https://cloud.ibm.com/apidocs/schematics/schematicsapply-workspace-command) to provision an Agent infrastructure.

curl -X PUT https://schematics.cloud.ibm.com/v1/workspaces/{w_id}/apply -H 'authorization: <auth>' -H 'cache-control: no-cache' -H 'content-type: application/json' -d '{
The values returned are typically an application URL or the IDs of provisioned resources.
* Optional: Create a readme file to document the template, inputs, and outputs. Best practice is to include an image of the reference architecture.



3. Push the completed blueprint template to a Git repo. If needed, create a Git version release tag for blueprint version management. [Semantic versioning](https://semver.org/) is strongly recommended.
4. Customize your template with a versioned blueprint input file to configure it for your use case.



* Review the section on [Customizing environments with inputs](https://cloud.ibm.com/docs/schematics?topic=schematics-define-blueprintsdefine-blueprint-steps) to determine which inputs will be defined in the input file. Undefined inputs, must either have a template default or be specified at runtime by a dynamic input. - Review the sections [Understanding blueprint templates and configuration](https://cloud.ibm.com/docs/schematics?topic=schematics-blueprint-templates) and [blueprint input YAML schema](https://cloud.ibm.com/docs/schematics?topic=schematics-bp-input-schema-yaml) for the syntax to define blueprint input files.
* Again in your favorite editor, create and name a new blueprint input YAML file. Alternatively follow the instructions for [editing templates in VSCode](https://cloud.ibm.com/docs/schematics?topic=schematics-edit-blueprints).
* Using the template inputs as a guide, populate the input file with environment-specific input key-value pairs. The variable type of the input value must match that defined in the template YAML file.
* It is recommended that inputs defining secrets or sensitive values are omitted from the input file.Then specified when the blueprint configuration is created in Schematics.



5. Push the blueprint input YAML file to a Git repo. As required, create a Git version release tag for version management.
: IBM Cloud Schematics supports public bit bucket repository as a template repository source. Private bit bucket repository needs a workaround. Download the files from the repository, then, you need to tar the files and upload in the IBM Cloud Schematics Workspace.







 July 2020 

Review the release notes for July 2020.



 9 July 2020 

Stop apply support
: IBM Cloud Schematics now supports stopping a Schematics apply action that currently runs against your workspace from the console and the API. For more information, see [Managing resource life cycles](https://cloud.ibm.com/docs/schematics?topic=schematics-manage-lifecycle) or use the [DELETE /v1/workspaces/{id}/actions/{action_id}](https://cloud.ibm.com/apidocs/schematics/schematicsstop-a-schematics-apply-action) API.

New Schematics locations
: You can now create Schematics Workspaces in the Frankfurt or London location by using the location selector from the Schematics console or targeting the matching IBM Cloud region through CLI. For more information, see [Locations and service endpoints](https://cloud.ibm.com/docs/schematics?topic=schematics-locations) and [Where is my data stored?](https://cloud.ibm.com/docs/schematics?topic=schematics-secure-datapi-location)







 June 2020 

Review the release notes for June 2020.



 26 June 2020 

Ansible provisioner support
: You can now use the Ansible provisioner with IBM Cloud Schematics to deploy software on IBM Cloud resources or perform actions against your resources, such as shutting down a virtual server instance.
Schematics Blueprints is a [beta feature](https://cloud.ibm.com/docs/schematics?topic=schematics-bp-beta-limitations) that are available for evaluation and testing purposes. It is not intended for production usage. Refer to the list of [limitations](https://cloud.ibm.com/docs/schematics?topic=schematics-bp-beta-limitationssc-bp-beta-limitation) for the beta release.



 Blueprint create fails 

Review the following sections to help debugging blueprint apply failures.



 Blueprint create fails with an invalid blueprint template: failed to clone Git repository error 

 What’s happening 

When you create a blueprint configuration, the create fails with an error that the template, or input repositories cannot be cloned or found.

 Why it’s happening 

When you create the configuration, Schematics attempts to download the input files and blueprint template from the Git repositories that are specified on the create and validate the YAML schema.

Sample error

FAILED
Could not create the blueprint. Please verify that your request is correct. If the problem persists, contact IBM Cloud support.

Invalid blueprint templates. Error - Failed to clone git repository, repository not found (check url, also check the scope 'repo' of the personal access token if SCHEMATICSGITTOKEN is used)

 How to fix it 

Check that the source repositories for the templates and input files are correctly specified, the referenced files and repository exists and is accessible with Git tokens specified whether necessary.

Rerun the blueprint create operation with the correct repository reference.





 Blueprint create fails with an invalid blueprint template: unable to find file error 

 What’s happening 

When you create the configuration, the create fails before the config is created with an error that the template, or input files cannot be found.

 Why it’s happening 

When you create the configuration, Schematics attempts to download the input files, and template from the Git repositories that are specified on the create and validate the YAML schema.
FAQs: Image templates 



 What is a standard image template? 

A standard image template is the IBM® Virtual Servers imaging option for IBM Cloud. You use standard image templates to capture an image of an existing virtual server instance regardless of its operating system and create a new virtual server that is based on the image.





 What is an ISO template? 

The ISO template is a type of template that is reserved for ISOs that can be used to start a virtual server instance. ISO templates are available in two versions: public and private. Public ISO templates are preconfigured templates that are provided by IBM Cloud and can be used by any customer. Private ISO templates are created by importing an image of an ISO stored on an Object Storage account. In order for an ISO to be imported to the Image Templates screen, the ISO must be bootable.

IBM Cloud supported operating systems can be used only to load an ISO template onto an instance. For more information, see [Supported Operating Systems](https://cloud.ibm.com/docs/bare-metal?topic=bare-metal-about-software&locale=ensupported-operating-systems-for-ibm-cloud-virtual-servers).





 What is the difference between a public image and a private image? 

A public image is an image that can be viewed and applied to a new virtual server by any IBM Cloud user. IBM Cloud currently creates public images as a solution for configuration options on different devices. You can also make images public and available to any user. A private image is an image that can be viewed only by authorized users. Authorized users default to any user on your account; however, images also can be shared between multiple accounts by updating the sharing options in the IBM Cloud console.





 Can I capture and deploy virtual servers with my self-managed hypervisor? 

Only servers that are provisioned by IBM Cloud can be captured and deployed. Individual virtual servers that you manually created on personal devices cannot be captured, provisioned, or deployed.





 Can I share my private ISO template with other customers? 

The only ISO templates that are made public to all customers are templates that are generated by IBM Cloud.
Schematics Blueprints is a [beta feature](https://cloud.ibm.com/docs/schematics?topic=schematics-bp-beta-limitations) that are available for evaluation and testing purposes. It is not intended for production usage. Refer to the list of [limitations](https://cloud.ibm.com/docs/schematics?topic=schematics-bp-beta-limitationssc-bp-beta-limitation) for the beta release.



 Schematics Blueprints 

Schematics Blueprints brings [infrastructure as code (IaC) practices](https://cloud.ibm.com/docs/schematics?topic=schematics-infrastructure-as-code) to the creation and lifecycle management of large-scale and complex cloud environments. Blueprints manages operations across multiple environments to scale cloud environments from their initial creation, through maintenance and ops to final decommissioning and clean up of all allocated resources.



 Overview 

IBM Cloud® Schematics Blueprints is an Infrastructure as Code (IaC) automation solution for large-scale cloud environments. It utilizes the analogy of building a house from a blueprint drawing. Where a blueprint defines the architecture, layout, the major building blocks and standard components. Using the blueprint for guidance, a builder can confidently build the house from the set of well-defined components.

In the same way, Schematics Blueprints enables users to define and deploy complex cloud environments using modules of reusable and well-defined [Terraform](https://www.terraform.io) automation code. This builds on the IaC best practice of [modular architectures](https://cloud.ibm.com/docs/schematics?topic=schematics-infrastructure-as-codeiac-bp-modularity). It [scales the Terraform deployment model](https://cloud.ibm.com/docs/schematics?topic=schematics-blueprint-scaling), by connecting modular IaC environments, as the layers and components of large infrastructure architectures. The definition of an architecture using modules and deployment as linked environments is illustrated.

Zoom

!
* When are the new Terraform and Ansible versions added to Schematics?

After new Terraform and Ansible versions are released by the community, the IBM team begins hardening and testing the release for Schematics. Availability of new versions depends on the results of these tests, community updates, security patches, and technology changes between versions. Make sure that your Terraform templates and Ansible playbooks are compatible with one of the supported versions so that you can run them in Schematics. For more information, see [Upgrading the Terraform template version](https://cloud.ibm.com/docs/schematics?topic=schematics-migrating-terraform-version) and [Schematics runtime tools](https://cloud.ibm.com/docs/schematics?topic=schematics-sch-utilitiessch-runtime-tf-job).
* Can I run Ansible playbooks with Schematics?

Yes, you can run Ansible playbooks against your IBM Cloud by using the Schematics Actions or Ansible provisioner in your Terraform configuration file. For example, use the Ansible provisioner to deploy software on IBM Cloud resources or set actions against your resources, such as shutting down a virtual server instance. For more information, see [sample Ansible playbook templates for Schematics Actions](https://cloud.ibm.com/docs/schematics?topic=schematics-sample_actiontemplates).
* What are the updates in the agent beta-1 release?

The following are the features in Agent beta-1 release.



* Improvements to the agent deployment experience through CLI.
* Support to run Ansible playbooks on the agent.
* Dynamic assignment of workspace or action jobs to the agent.



* What are the costs of installing and using Agents?

The following are the cost break-down for the Schematics Agent.

Pre-requisite: Agent infrastructure



* Cost of VPC infrastructure elements such as, subnet, public gateways.
* Cost of IBM Kubernetes Service (cluster) on VPC, with three-node worker pool.
* Cost of IBM Cloud Object Storage



Agent beta-1 service
The CLI uses geographic specific API endpoints which direct job requests to the first available region within a geography. us.schematics.cloud.ibm.com is called irrespective of the target us-south or us-east region and similarly, eu.schematics.cloud.ibm.com is called irrespective of the target eu-gb or eu-de region. Schematics dynamically determines which region to send the request based on region availability. Config targeted to us-south during creation, will be automatically run on us-east if us-south is not available.

This behavior is similar in the UI. For example, in the Schematics Workspace creation page, you select North America region from the list.
* Is it possible to delete the Schematics service instance by using the Resource Controller API or CLI?

You cannot delete the Schematics service instance. Instead you can destroy the cloud resources that are created by using Schematics Terraform and delete the Schematics objects such as workspace, or an action.

Schematics service is provisioned for the following reasons.



* Whenever Schematics service is used for the first time, you do not explicitly provision the Schematics.
* Schematics is a free service, not charged for the service instance.



There is no plan to add this feature to delete the Schematics service instance.
* What is IBM Cloud Schematics and how does it work?

IBM Cloud Schematics provides powerful tools to automate your cloud infrastructure provisioning and management process, the configuration and operation of your cloud resources, and the deployment of your app workloads.

To do so, Schematics uses open source projects, such as Terraform, Ansible, Red Hat OpenShift, Operators, and Helm, and delivers these capabilities to you as a managed service. Rather than installing each open source project on your system, and learn the API or CLI. You can declare the tasks that you want to run in IBM Cloud and watch Schematics run these tasks for you.
Creating a deployment to IBM Cloud Schematics link 

The deploy to IBM Cloud® URL is an efficient way for you to enable users to deploy solutions on IBM Cloud from a public Git repository sample configuration. The URL requires minimal configuration and you can insert it anywhere in your documentation that supports markup. When the user clicks the hyper link, they are taken directly to the Schematics workspace setup page and only need to click the create button for workspace creation in Schematics.

The following steps show how to create a URL to deploy to Terraform >=1.0.0, <2.0 template example in IBM Cloud Schematics.



1. Create a template example by using Terraform on IBM Cloud provider and publish in the public Git repository. To create example, see [Sample template](https://github.com/IBM-Cloud/terraform-provider-ibm/tree/master/examples).
2. Copy the public Git repository URL, for example, https://github.com/IBM-Cloud/terraform-provider-ibm/tree/master/examples/ibm-api-gateway.
3. Use this syntax to auto deploy the Schematics workspace creation in the IBM Cloud.

Syntax

https://cloud.ibm.com/schematics/workspaces/create?repository=<template public Git repository example url>&terraform_version=<terraform_v1.x.x>

Example

https://cloud.ibm.com/schematics/workspaces/create?repository=https://github.com/IBM-Cloud/terraform-provider-ibm/tree/master/examples/ibm-api-gateway&terraform_version=terraform_v1.0

The URL contains two parameters, first parameter is provided with the workspace name as ibm-api-gateway and second parameter is provided with the Terraform version as terraform_v1.0.
The section [Orchestration and modules](https://cloud.ibm.com/docs/schematics?topic=schematics-blueprint-scalingblueprint-scaling-orchestration) describes the design philosophy of the design and usage of modules within the Blueprints orchestration framework. See the [IBM module authoring guidelines](https://terraform-ibm-modules.github.io/documentation//implementation-guidelines) for creating user modules compliant with Schematics Blueprints.

The combination of IBM and user modules from public and private repos to create a custom template is illustrated in the figure.

Zoom

![Custom templates with public and private modules](https://cloud.ibm.com/docs-content/v1/content/ba89e173287b28d1453d2a327d8a1f74ae2f1662/schematics//images/new/bp-terraform-modules.svg)

Custom templates with public and private modules

The template determines the architecture, specifying the modules required for the implementation and their source repositories. As illustrated publicly available module functionality can be combined with third-party and user developed modules to create customized solutions.

Templates support the use of both Terraform [root modules](https://developer.hashicorp.com/terraform/language/modulesthe-root-module) and Terraform [child](https://developer.hashicorp.com/terraform/language/moduleschild-modules) modules. Root modules can be used by referencing the source library and passing the required inputs. Reusable child modules require additional blueprint template injector parameters to enable usage with templates. Use of injector parameters is described in the next sections.



 Root modules and Terraform configurations 

A root module is the root of an executable Terraform configuration. A root module, also known as a Terraform config or Terraform template and can be run directly by the Terraform command line binary or Schematics.

A Terraform configuration consists of a root module as the main directory that contains .tf files.
* [18 November 2022](https://cloud.ibm.com/docs/schematics?topic=schematics-schematics-relnotesschematics-nov1822)



* Release Schematics command-line plug-in.



* [15 November 2022](https://cloud.ibm.com/docs/schematics?topic=schematics-schematics-relnotesschematics-nov1522)



* Release Schematics Agents GitHub repository.



* [14 November 2022](https://cloud.ibm.com/docs/schematics?topic=schematics-schematics-relnotesschematics-nov1422)



* Schematics Blueprints template schema changes.



* [03 November 2022](https://cloud.ibm.com/docs/schematics?topic=schematics-schematics-relnotesschematics-nov0322)



* Release Schematics command-line plug-in.





* [September 2022](https://cloud.ibm.com/docs/schematics?topic=schematics-schematics-relnotesschematics-sept22)



* Schematics deprecates Python v3.6 and upgrades the Schematics Job image to use Python v3.8 by mid of September 2022. For more information, see [Schematics announcement](https://cloud.ibm.com/status/announcement?component=schematics) tools.
* Review the release notes for September 2022.
* [21 September 2022](https://cloud.ibm.com/docs/schematics?topic=schematics-schematics-relnotesschematics-sept2222)



* The Schematics Job image supports Python v3.8





* [August 2022](https://cloud.ibm.com/docs/schematics?topic=schematics-schematics-relnotesschematics-aug22)



* Review the release notes for August 2022.
Schematics Blueprints is a [beta feature](https://cloud.ibm.com/docs/schematics?topic=schematics-bp-beta-limitations) that are available for evaluation and testing purposes. It is not intended for production usage. Refer to the list of [limitations](https://cloud.ibm.com/docs/schematics?topic=schematics-bp-beta-limitationssc-bp-beta-limitation) for the beta release.



 Deleting blueprints 

When the application that is hosted in the blueprint environment is no longer needed, or has been migrated into a new environment, the original environment can be deleted. All the cloud resources that are deployed and managed by the blueprint environment are cleaned up and destroyed, which stops billing for any chargeable resources.

Deleting a blueprint environment is currently a two-step process, resource deletion followed by deleting the Schematics blueprint configuration. In a future release an additional plan step will be added before the resource destroy to allow verification of the proposed changes before executing the operation.

The first step destroys all the deployed cloud resources, leaving the blueprint configuration in place. The second step, deletes the blueprint configuration from Schematics. This flow is illustrated in the diagram.

Zoom

![Deleting a blueprint environment](https://cloud.ibm.com/docs-content/v1/content/ba89e173287b28d1453d2a327d8a1f74ae2f1662/schematics//images/new/sc-bp-delete.svg)

Deleting a blueprint environment



1. In a future release blueprints will provide the option to preview the resources that will be deleted.
2. The user initiates a destroy of the cloud resources that belong to the blueprint environment. The blueprint destroy operation iterates through all the blueprint modules, destroying resources in reverse dependency order to ensure that all cloud resources are cleanly removed. On resource destroy, all the modules return to an Inactive state to indicate that no cloud resources remain.