Empilhando arquiteturas usando a CLI

Depois de adicionar as arquiteturas implantáveis ao seu projeto, empilhe-as executando o seguinte ibmcloud project config-create comando. No Definition opção, especifique o members fornecendo um nome e o ID de configuração para as arquiteturas implantáveis existentes que você deseja empilhar:

ibmcloud project config-create --project-id PROJECT-ID [--definition DEFINITION]

Por exemplo, o comando a seguir cria uma arquitetura implantável chamada StackDev no seu projeto. Ele contém duas arquiteturas implantáveis, custom-apache e test-slz que já foram adicionadas como configurações ao projeto:

ibmcloud project config-create \
  --project-id 0e13c360-45c4-4b68-a53f-bb8f6ac04161 \
  --definition '{"name": "StackDev", "members": [{"name": "custom-apache", "config_id": "caff3a49-0bf4-40c4-b348-47e5da6e2274"}, {"name": "test-slz", "config_id": "fc7fa3d1-33db-4c40-9570-7604348ab3c4"}]}' \
  --output json

Para obter mais informações sobre os parâmetros de comando, consulte ibmcloud project config-create.

Criação da definição de pilha usando a CLI

Para integrar sua arquitetura implantável a um catálogo privado, você deve criar uma definição de pilha. Ele define como cada arquitetura implantável se relaciona entre si. Forneça essas informações para que os usuários possam implantar a solução inteira com sucesso ao adicioná-la a um projeto do catálogo privado.

A definição de pilha contém entradas e saídas que podem ser referenciadas em arquiteturas implantáveis de membros. Você também pode incluir referências entre arquiteturas implantáveis, o que as vincula para os usuários. Entradas que exigem um valor ou referência específica para implantação bem-sucedida precisam ser incluídas na definição de pilha.

Atualmente, os membros não podem referenciar saídas da definição de pilha.

Execute o seguinte ibmcloud project stack-definition-create comando para criar a definição de pilha e fornecer as entradas:

ibmcloud project stack-definition-create --project-id PROJECT-ID --id

Onde id é o ID de configuração do StackDev arquitetura implantável que você acabou de criar em seu projeto.

Por exemplo, o comando a seguir adiciona as três entradas a seguir à definição de pilha. Essas entradas são sequências de caracteres necessárias que não são ocultadas dos usuários, portanto, os usuários devem configurar esses valores de entrada para implantar a arquitetura implantável de ponta a ponta:

• prefix entrada com stackDemo como valor padrão.
• ssh_key entrada sem valor padrão.
• ssh_private_key com um valor padrão fornecido para auxiliar os usuários na configuração da entrada.

O comando também inclui nomes de entrada para as duas arquiteturas implantáveis que são empilhadas juntas. Essas entradas serão preenchidas com valores como referências e salvas para usuários que adicionarem a solução a um projeto do catálogo privado:

• O test-slz arquitetura implantável contém um prefix entrada e uma ssh_key entrada.
• O custom-apache arquitetura implantável contém um ssh_private_key entrada e uma prerequisite_workspace_id entrada.

Para obter mais informações sobre como escrever referências, consulte referenciando valores.

ibmcloud project stack-definition-create \
--project-id 0e13c360-45c4-4b68-a53f-bb8f6ac04161 \
--id 4d69cee6-0fb2-4621-96c6-16d987f3d9d7 \
--stack-definition '{"inputs": [{"name": "prefix", "type": "string", "hidden": false, "required": true, "default": "stackDemo"}, {"name": "ssh_key", "type": "string", "hidden": false, "required": true}, {"name": "ssh_private_key", "type": "string", "hidden": false, "required": true, "default": "<<-EOF\nINSERT YOUR KEY HERE\nEOF"}], "members": [{"name": "test-slz", "inputs": [{"name": "prefix"}, {"name": "ssh_key"}]}, {"name": "custom-apache", "inputs": [{"name": "ssh_private_key"}, {"name": "prerequisite_workspace_id"}]} ]}' --output json

Para obter mais informações sobre os parâmetros de comando, consulte ibmcloud project stack-definition-create.

Referenciando entradas da definição de pilha dentro de arquiteturas implantáveis de membros usando a CLI

Agora que as entradas foram adicionadas à definição de pilha, atualize as arquiteturas implantáveis dos membros para fazer referência a essas entradas executando o comando ibmcloud project config-update comando para cada arquitetura que você empilhou:

ibmcloud project config-update --project-id PROJECT-ID --id

Por exemplo, o comando a seguir atualiza o test-slz arquitetura implantável para referenciar as entradas que foram adicionadas à definição de pilha:

ibmcloud project config-update \
--project-id 0e13c360-45c4-4b68-a53f-bb8f6ac04161 \
--id fc7fa3d1-33db-4c40-9570-7604348ab3c4 \
--definition '{"inputs": {"prefix": "ref:../../inputs/prefix", "ssh_key": "ref:../../inputs/ssh_key"}}' --output json

Desde o custom-apache a arquitetura usa o ssh_private_key valor da definição da pilha, atualize o custom-apache arquitetura implantável para referenciar esse valor. O custom-apache a arquitetura também utiliza o schematics_workspace_id valor de entrada como uma de suas entradas, portanto inclua uma referência a esse valor:

ibmcloud project config-update \
--project-id 0e13c360-45c4-4b68-a53f-bb8f6ac04161 \
--id caff3a49-0bf4-40c4-b348-47e5da6e2274 \
--definition '{"inputs": {"ssh_private_key": "ref:../../inputs/ssh_private_key", "prerequisite_workspace_id": "ref:../test-slz/outputs/schematics_workspace_id"}}' --output json

Para obter mais informações sobre os parâmetros de comando, consulte ibmcloud project config-update.

Atualizando valores de entrada na definição de pilha usando a CLI

Agora que as arquiteturas implantáveis dos membros estão configuradas para referenciar os valores desejados, atualize os valores de entrada na definição da pilha executando ibmcloud project config-update para o StackDev arquitetura implantável. Por exemplo, o comando a seguir atualiza o prefix valor de entrada que é referenciado pelo test-slz arquitetura implantável. Os valores também são fornecidos para o ssh_key e ssh_private_key entradas:

ibmcloud project config-update  \
--project-id 0e13c360-45c4-4b68-a53f-bb8f6ac04161 \
--id 4d69cee6-0fb2-4621-96c6-16d987f3d9d7 \
--definition '{"inputs": {"prefix": "kb-stack-0327", "ssh_key": "<publicKey>", "ssh_private_key": "<privateKey>"}}' --output json

Para obter mais informações sobre os parâmetros de comando, consulte ibmcloud project config-update.

Agora que o valor de entrada está configurado, valide e implante cada arquitetura implantável do membro.

Por exemplo, o comando a seguir valida o test-slz arquitetura implantável:

ibmcloud project config-validate \
--project-id 0e13c360-45c4-4b68-a53f-bb8f6ac04161 \
--id fc7fa3d1-33db-4c40-9570-7604348ab3c4

Enquanto o comando a seguir aprova o test-slz arquitetura implantável para implantação:

ibmcloud project config-approve \
--project-id 0e13c360-45c4-4b68-a53f-bb8f6ac04161 \
--id fc7fa3d1-33db-4c40-9570-7604348ab3c4 \
--comment 'I approve'

E o comando a seguir implanta o test-slz arquitetura implantável:

ibmcloud project config-deploy \
--project-id 0e13c360-45c4-4b68-a53f-bb8f6ac04161 \
--id fc7fa3d1-33db-4c40-9570-7604348ab3c4

Integração a um catálogo privado usando a CLI

Depois que cada arquitetura implantável de membro for validada e implantada, você poderá integrar sua arquitetura implantável a um catálogo privado para que outros possam acessá-la. Quando um usuário adiciona sua arquitetura implantável a um projeto do catálogo privado, cada arquitetura que você empilhou é incluída no projeto. Execute o seguinte ibmcloud project stack-definition-export comando:

ibmcloud project stack-definition-export --project-id PROJECT ID

Você pode criar um novo produto ou adicionar uma versão a um produto existente. Por exemplo, o comando a seguir cria um novo produto em seu catálogo privado chamado My Apache Stack:

ibmcloud project stack-definition-export --project-id 0e13c360-45c4-4b68-a53f-bb8f6ac04161 --id 4d69cee6-0fb2-4621-96c6-16d987f3d9d7 --settings '{"catalog_id": "702ff97a-e35a-45a4-a0c0-a04e2e052bc8", "label": "My Apache Stack"}' --output json

Enquanto o comando a seguir cria uma nova versão de um produto existente:

ibmcloud project stack-definition-export \
--project-id 0e13c360-45c4-4b68-a53f-bb8f6ac04161 \
--id 4d69cee6-0fb2-4621-96c6-16d987f3d9d7 \
--settings '{"catalog_id": "702ff97a-e35a-45a4-a0c0-a04e2e052bc8", "product_id": "1bf57631-27a2-42cc-ac87-733cca67e8a5", "target_version": "1.0.1"}' --output json

Para obter mais informações sobre os parâmetros de comando, consulte ibmcloud project stack-definition-export.

Sua arquitetura agora é um rascunho no catálogo privado que ainda não foi publicado, mas está disponível para qualquer pessoa que tenha acesso de Editor ao catálogo privado.

Para concluir a integração ao seu catálogo privado, edite os detalhes do catálogo e forneça informações como um diagrama de arquitetura e uma categoria.

Empilhando arquiteturas usando o console

Depois de adicionar as arquiteturas implantáveis ao seu projeto, configure-as. Se as arquiteturas que você está empilhando dependem umas das outras, vincule-as referenciando entradas ou saídas conforme você as configura. Em seguida, empilhe as arquiteturas concluindo as seguintes etapas:

1. Marque a caixa de seleção para as arquiteturas implantáveis que você deseja empilhar.

2. Selecione Pilha.

3. Forneça um nome para as arquiteturas implantáveis ou selecione uma existente.

   As arquiteturas implantáveis devem trabalhar juntas para fornecer uma solução. Considere um nome significativo para a solução completa que represente com precisão cada arquitetura que você está empilhando. Por exemplo, se você estiver empilhando um aplicativo Apache junto com uma base de infraestrutura, nomeie-o como Apache application with infrastructure base para identificar claramente o que a arquitetura implementa.

4. Clique em Continuar.

Definindo variáveis usando o console

Depois de empilhar as arquiteturas implantáveis, você precisa definir variáveis para seus usuários. Seu objetivo é vincular as arquiteturas implantáveis para que os usuários possam configurar entradas em uma única interface, em vez de configurar arquiteturas individualmente.

As variáveis de entrada que você define são configuradas pelos usuários depois que a arquitetura implantável é adicionada a um projeto a partir de um catálogo. Da mesma forma, as variáveis de saída selecionadas são exibidas para usuários no nível pai da arquitetura. Não selecione variáveis que os usuários não devem configurar. Por exemplo, se sua arquitetura exigir um valor específico para uma variável de entrada, como um plano de armazenamento, não selecione a entrada do plano de armazenamento. Não selecione referências que vinculem as arquiteturas implantáveis. Se você fizer isso, a conexão entre essas arquiteturas poderá ser interrompida e a solução inteira poderá não ser implantada com sucesso.

Para facilitar a configuração para os usuários, minimize o número de valores de entrada necessários. Revise as entradas necessárias para cada arquitetura e certifique-se de que elas estejam configuradas adicionando referências aos valores de entrada na definição da pilha ou referenciando valores de saída de outras arquiteturas.

Conclua as etapas a seguir:

1. Na guia Configurações do seu projeto, clique no ícone Opções Ícone para a arquitetura implantável empilhada e selecione Definir variáveis.

2. Na guia Segurança, selecione quaisquer variáveis que os usuários precisam configurar.

3. Vá para a aba Entradas necessárias e selecione quaisquer entradas necessárias que os usuários precisam configurar.

4. Vá para a aba Entradas opcionais e selecione quaisquer entradas opcionais que os usuários precisam configurar.

5. Vá para a aba Saídas e selecione quaisquer variáveis de saída que você deseja exibir no nível pai.

   Facilite para os usuários encontrarem valores de saída importantes após a implantação da arquitetura, como URLs de aplicativos ou nomes de credenciais. Selecione os valores de saída importantes das arquiteturas implantáveis de membros para exibi-los para usuários no nível pai.

6. Clique em Avançar e continue selecionando variáveis para as arquiteturas restantes.

7. Quando terminar, clique em Concluir e configure a arquitetura para implantação. Quaisquer entradas que você selecionou ao definir as variáveis podem precisar ser configuradas.

Integração a um catálogo privado usando o console

Depois de validar e implantar cada uma das arquiteturas implantáveis que você empilhou, você pode adicioná-las como uma arquitetura implantável a um catálogo privado para compartilhar facilmente a solução com outras pessoas na sua organização. Para obter mais informações, consulte compartilhamento de um catálogo privado.

Conclua as etapas a seguir:

1. Na guia Configurações do seu projeto, clique no ícone Opções Ícone para a arquitetura implantável e selecione Adicionar ao catálogo privado.
2. Selecione ou crie o catálogo privado ao qual você deseja adicionar a arquitetura implantável.
3. Selecione se é um novo produto ou uma nova versão de um produto existente.
4. Forneça detalhes como o nome do produto, se aplicável, a categoria, variação e versão.
5. Clique em Avançar.
6. Revise as variáveis que os usuários podem configurar depois de adicionar arquitetura implantável a um projeto do catálogo privado. Se precisar fazer alguma alteração, você pode definir as variáveis.
7. Clique em Incluir.

Sua arquitetura implantável agora é um rascunho no catálogo privado que ainda não foi publicado, mas está disponível para qualquer pessoa que tenha acesso de Editor ao seu catálogo privado. Quando um usuário adiciona sua arquitetura implantável a um projeto do catálogo privado, cada arquitetura que você empilhou é incluída no projeto.

Para concluir a integração da sua arquitetura implantável ao seu catálogo privado, edite os detalhes do catálogo e forneça informações como um diagrama de arquitetura e uma categoria.

Há uma nova versão disponível para uma arquitetura implantável que você empilhou com outras? Atualize a configuração do seu projeto para usar a versão mais recente, valide e implante as alterações e conclua as etapas para integrar a solução atualizada a um catálogo privado. Selecione o produto existente que você já integrou e forneça um novo número de versão. Ao fazer isso, você ajuda a garantir que a arquitetura implantável atualizada ainda funcione corretamente com as outras arquiteturas que você empilhou junto com ela.