Ambientes de desenvolvimento rápido rapid-development-environments

Para implantar alterações, os ambientes de desenvolvimento de nuvem atuais exigem o uso de um processo que emprega regras abrangentes de segurança e qualidade de código chamadas de pipeline de CI/CD. Para situações em que são necessárias alterações rápidas e iterativas, a Adobe introduziu os RDEs (Rapid Development Environments, ambientes de desenvolvimento rápido).

Os RDEs permitem que os desenvolvedores implantem e revisem alterações rapidamente, minimizando o tempo necessário para testar recursos que comprovadamente funcionam em um ambiente de desenvolvimento local.

Depois que as alterações forem testadas em um RDE, elas poderão ser implantadas em um ambiente de desenvolvimento de nuvem regular por meio do pipeline do Cloud Manager.

Você pode ver vídeos adicionais demonstrando como configurá-lo, como usá-lo e o ciclo de vida de desenvolvimento usando RDE.

Introdução introduction

Os RDEs podem ser usados para configurações de código, conteúdo e Apache ou Dispatcher. Diferentemente dos ambientes de desenvolvimento de nuvem comuns, os desenvolvedores podem usar ferramentas de linha de comando locais para sincronizar o código criado localmente em um RDE.

Cada programa é provisionado com um RDE. Se houver contas de sandbox, elas hibernarão após algumas horas de inatividade.

Após a criação, os RDEs são definidos para a versão mais recente do Adobe Experience Manager (AEM). Uma redefinição de RDE, que pode ser executada usando o Cloud Manager, transforma o RDE e o define para a versão mais recente do AEM disponível.

Normalmente, um RDE é usado por um único desenvolvedor em um determinado momento, para testar e depurar um recurso específico. Quando a sessão de desenvolvimento for concluída, o RDE poderá ser redefinido para um estado padrão para o próximo uso.

RDEs adicionais podem ser licenciados para programas de produção (não sandbox).

Ativar o RDE em um programa enabling-rde-in-a-program

A tela Visão geral agora exibe seu novo ambiente no cartão Ambientes.

Após a criação, os RDEs são definidos com a versão mais recente disponível do AEM. Uma redefinição de RDE, que também pode ser executada usando o Cloud Manager, transforma o RDE e o define para a versão mais recente do AEM disponível.

Para obter mais informações sobre como usar o Cloud Manager para criar ambientes, gerenciar quem tem acesso a eles e atribuir domínios personalizados, consulte Programas e Tipos de Programas na documentação do Cloud Manager.

Instalar as ferramentas de linha de comando do RDE installing-the-rde-command-line-tools

Depois de ter adicionado um RDE para seu programa usando o Cloud Manager, você pode interagir com ele configurando as ferramentas de linha de comando conforme descrito nas seguintes etapas:

Configuração interativa installing-the-rde-command-line-tools-interactive

O comando setup pergunta se a configuração fornecida deve ser armazenada local ou globalmente.

Setup the CLI configuration necessary to use the RDE commands.
? Do you want to store the information you enter in this setup procedure locally? (y/N)

Escolha no para

Escolha yes para fazer o seguinte:

Depois que a configuração local ou global for selecionada, o comando de configuração tentará ler a ID da organização no logon atual e, em seguida, ler os programas da organização. Caso a organização não possa ser encontrada, você poderá inseri-la manualmente junto com algumas orientações.

Selected only organization: XYXYXYXYXYXYXYXXYY
retrieving programs of your organization ...

Depois que os programas forem recuperados, o usuário poderá selecionar na lista e também digitar para filtrar. Quando o programa é selecionado, uma lista de ambientes RDE é listada para escolher. Se houver apenas um programa, ou apenas um ambiente RDE disponível, ou ambos, ele será selecionado automaticamente.

Para ver o contexto do ambiente atual, execute o seguinte:

aio aem rde setup --show

O comando responde com um resultado semelhante ao seguinte:

Current configuration: cm-p1-e1: programName - environmentName (organization: ...@AdobeOrg)

Procedimento de configuração manual em um ambiente não interativo manual-setup

Em ambientes em que nenhum usuário pode executar interativamente o comando de configuração (como CI/CD ou scripts), a configuração manual é necessária. Você pode definir os parâmetros de organização, programa e ambiente usando as etapas abaixo.

Usar o RDE ao desenvolver um novo recurso using-rde-while-developing-a-new-feature

A Adobe recomenda o seguinte fluxo de trabalho para desenvolver um novo recurso:

Usar RDE para depurar um recurso existente use-rde-to-debug-an-existing-feature

O fluxo de trabalho é semelhante ao desenvolvimento de um novo recurso. A diferença é que o código sincronizado com o RDE reflete o rótulo do Git do que foi enviado para o ambiente em que o problema ocorreu. Esse fluxo de trabalho ajuda a garantir a consistência ao investigar ou reproduzir o problema. Além disso, pode ser útil implantar o conteúdo correspondente ao ambiente de upstream. Essa abordagem pode ser alcançada por meio da exportação e importação de pacotes de conteúdo.

Vários desenvolvedores colaborando no mesmo RDE multiple-developers-collaborating-on-the-same-rde

Um RDE suporta um único projeto por vez. Como o código é sincronizado de um ambiente de desenvolvimento local para o ambiente RDE, é mais natural que um desenvolvedor o use sozinho em um determinado momento.

No entanto, com uma coordenação cuidadosa, é possível que mais de um desenvolvedor valide um recurso específico ou depure um problema específico. A chave é que cada desenvolvedor mantém seus projetos locais sincronizados para que as alterações de código feitas por um determinado desenvolvedor sejam absorvidas pelos outros desenvolvedores. Caso contrário, um desenvolvedor pode, inadvertidamente, substituir o código do outro. A estratégia recomendada é que cada desenvolvedor confirme suas alterações em uma ramificação Git compartilhada antes de sincronizar com o RDE, para que os outros desenvolvedores extraiam as alterações antes de fazer suas próprias alterações.

Comandos das ferramentas de linha de comando do RDE rde-cli-commands

Ajuda/Informações gerais help

Sinalizadores globais global-flags

Implantar no RDE deploying-to-rde

Esta seção explica como usar a CLI do RDE para implantar, instalar ou atualizar vários recursos. Esses recursos incluem o seguinte:

O padrão de uso geral é aio aem:rde:install <artifact>.

Você pode encontrar alguns exemplos abaixo:

Implantar um pacote de conteúdo deploy-content-package

aio aem:rde:install sample.demo.ui.apps.all-1.0.0-SNAPSHOT.zip

A resposta para uma implantação bem-sucedida se assemelha ao seguinte:

...
#1: deploy completed for content-package sample.demo.ui.apps.all-1.0.0-SNAPSHOT.zip on author,publish - done by 9E072FC75D54FE1A2B49431C@AdobeID at 2022-09-13T11:32:06.229Z

Como opção, você pode fazer referência a um repositório remoto:

aio aem:rde:install -t content-package "https://repo1.maven.org/maven2/com/adobe/aem/guides/aem-guides-wknd.all/2.1.0/aem-guides-wknd.all-2.1.0.zip"

Por padrão, os artefatos são implantados nos níveis de criação e publicação, mas o sinalizador -s pode ser usado para direcionar uma camada específica.

Qualquer pacote do AEM pode ser implantado, como pacotes com código, conteúdo ou um pacote de contêiner (também chamado de pacote "all").

Implantar uma configuração OSGI deploy-OSGI-config

aio aem:rde:install com.adobe.granite.demo.MyServlet.cfg.json

Onde a resposta para uma implantação bem-sucedida se assemelha ao seguinte:

...
#2: deploy completed for osgi-config com.adobe.granite.demo.MyServlet.cfg.json on author,publish - done by 9E0725C05D54FE1A0B49431C@AdobeID at 2022-09-13T11:54:36.390Z

Implantar um pacote deploy-bundle

Para implantar um pacote, use:

aio aem:rde:install ~/.m2/repository/org/apache/felix/org.apache.felix.gogo.jline/1.1.8/org.apache.felix.gogo.jline-1.1.8.jar

Onde a resposta para uma implantação bem-sucedida se assemelha ao seguinte:

...
#3: deploy staged for osgi-bundle org.apache.felix.gogo.jline-1.1.8.jar on author,publish - done by 9E0725C05D53BE1A0B49431C@AdobeID at 2022-09-14T07:54:28.882Z

Implantar um arquivo de conteúdo deploy-content-file

Para implantar um arquivo de conteúdo, use:

aio aem:rde:install world.txt -p /apps/hello.txt

Onde a resposta para uma implantação bem-sucedida se assemelha ao seguinte:

..
#4: deploy completed for content-file world.txt on author,publish - done by 9E0729C05C54FE1A0B49431C@AdobeID at 2022-09-14T07:49:30.644Z

Implantar uma configuração do Apache/Dispatcher deploy-apache-config

A estrutura de pastas inteira deve estar no formato de um arquivo zip para esse tipo de configuração.

No módulo dispatcher de um projeto do AEM, você pode compactar a configuração do Dispatcher executando o comando maven abaixo:

mvn clean package

Ou usando o comando zip abaixo do diretório src do módulo dispatcher:

zip -y -r dispatcher.zip .

Em seguida, implante a configuração com este comando:

aio aem:rde:install target/aem-guides-wknd.dispatcher.cloud-X.X.X-SNAPSHOT.zip

Uma implantação bem-sucedida gera uma resposta que se assemelha ao seguinte:

..
#5 deploy completed for dispatcher-config dispatcher.zip on author,publish - done by 9E0735C05T54FE1A0B49431C@AdobeID at 2022-10-03T10:26:31.286Z
Logs:
  Cloud manager validator 2.0.49
  2022/10/03 10:26:37 No issues found
  Syntax OK

O código implantado no RDE não é submetido a um pipeline de Cloud Manager e seus quality gates (portais de qualidade) associados. No entanto, o código passa por alguma análise, que relata os erros, conforme ilustrado na amostra de código abaixo:

$ aio aem:rde:install ~/.m2/repository/org/apache/felix/org.apache.felix.gogo.jline/1.1.8/org.apache.felix.gogo.jline-1.1.8.jar
...
#19: deploy staged for osgi-bundle org.apache.felix.gogo.jline-1.1.8.jar on author,publish - done by 9E0725C05D74FR1A0B49431C@AdobeID at 2022-09-14T07:54:28.882Z
Logs:
The analyser found the following errors for author :
[requirements-capabilities] com.adobe.aem.temp:org.apache.felix.gogo.jline:1.1.8: Artifact com.adobe.aem.temp:org.apache.felix.gogo.jline:1.1.8 requires [org.apache.felix.gogo.jline/1.1.8] org.apache.felix.gogo; filter:="(&(org.apache.felix.gogo=command.implementation)(version>=1.0.0)(!(version>=2.0.0)))"; effective:=active in start level 20 but no artifact is providing a matching capability in this start level.
[api-regions-exportsimports] com.adobe.aem.temp:org.apache.felix.gogo.jline:1.1.8: Bundle org.apache.felix.gogo.jline:1.1.8 is importing package(s) [org.jline.builtins, org.jline.utils, org.apache.felix.service.command, org.apache.felix.service.threadio, org.jline.terminal, org.jline.reader, org.apache.felix.gogo.runtime, org.jline.reader.impl] in start level 20 but no bundle is exporting these for that start level.
The analyser found the following errors for publish :
[requirements-capabilities] com.adobe.aem.temp:org.apache.felix.gogo.jline:1.1.8: Artifact com.adobe.aem.temp:org.apache.felix.gogo.jline:1.1.8 requires [org.apache.felix.gogo.jline/1.1.8] org.apache.felix.gogo; filter:="(&(org.apache.felix.gogo=command.implementation)(version>=1.0.0)(!(version>=2.0.0)))"; effective:=active in start level 20 but no artifact is providing a matching capability in this start level.
[api-regions-exportsimports] com.adobe.aem.temp:org.apache.felix.gogo.jline:1.1.8: Bundle org.apache.felix.gogo.jline:1.1.8 is importing package(s) [org.jline.builtins, org.jline.utils, org.apache.felix.service.command, org.apache.felix.service.threadio, org.jline.terminal, org.jline.reader, org.apache.felix.gogo.runtime, org.jline.reader.impl] in start level 20 but no bundle is exporting these for that start level.

A amostra de código acima ilustra o comportamento se um pacote não resolver. Nesse caso, ele é "preparado" e só será instalado se seus requisitos (nesse caso, importações ausentes) forem atendidos por meio da instalação de outro código.

Implantar configuração relacionada ao pipeline de configuração (configurações yaml) deploy-config-pipeline

As configurações específicas do ambiente (um ou mais arquivos yaml) descritas no artigo Uso dos Pipelines de Configuração podem ser implantadas da seguinte maneira:

aio aem:rde:install -t env-config ./my-config-folder
Onde my-config-folder é a pasta pai que contém as configurações yaml.

Como alternativa, também é possível instalar um arquivo zip contendo a árvore de pastas de configuração:

aio aem:rde:install -t env-config config.zip

Observe que a matriz envTypes do arquivo yaml inclui o valor rde, como no exemplo abaixo:

kind: "CDN"
version: "1"
metadata:
  envTypes: ["rde"]

Implantar código front-end com base em temas de site e modelos de site deploying-themes-to-rde

Os RDEs oferecem suporte para código front-end criado com temas de site e modelos de site. Em vez de usar o Pipeline de front-end do Cloud Manager como outros tipos de ambiente, os RDEs implantam pacotes de front-end usando uma diretiva de linha de comando.

Como de costume, crie seu pacote de front-end usando npm:

npm run build

Ele gera uma pasta dist/, de modo que a pasta do pacote front-end contém um arquivo package.json e uma pasta dist:

ls ./path-to-frontend-pkg-folder/
...
dist
package.json

Agora, você está pronto para implantar o pacote de front-end no RDE apontando para a pasta do pacote de front-end da seguinte maneira:

aio aem:rde:install -t frontend ./path-to-frontend-pkg-folder/
...
#1: deploy completed for frontend frontend-pipeline.zip on author,publish - done by ... at 2024-01-18T15:33:22.898Z
Logs:
> Deployed artifact wknd-1.0.0-1705592008-26e7ec1a
> with workspace hash 692021864642a20d6d298044a927d66c0d9cf2adf42d4cca0c800a378ac3f8d3

Como alternativa, você pode compactar o arquivo package.json e a pasta dist e implantar esse arquivo zip:

zip -r frontend-pkg.zip ./path-to-frontend-pkg-folder/dist ./path-to-frontend-pkg-folder/package.json

aio aem:rde:install -t frontend frontend-pkg.zip
...
#1: deploy completed for frontend frontend-pipeline.zip on author,publish - done by ... at 2024-01-18T15:33:22.898Z
Logs:
> Deployed artifact wknd-1.0.0-1705592008-26e7ec1a
> with workspace hash 692021864642a20d6d298044a927d66c0d9cf2adf42d4cca0c800a378ac3f8d3

Verificar o status do RDE checking-rde-status

Você pode usar a CLI do RDE para verificar se o ambiente está pronto para ser implantado para, como quais implantações foram feitas por meio do plug-in RDE.

Executando o seguinte:

aio aem:rde:status

Retorna com o seguinte:

Info for cm-p12345-e987654
Environment: Ready
- Bundles Author:
 com.adobe.granite.sample.demo-1.0.0.SNAPSHOT
- Bundles Publish:
 com.adobe.granite.sample.demo-1.0.0.SNAPSHOT
- Configurations Author:
 com.adobe.granite.demo.MyServlet
- Configurations Publish:
 com.adobe.granite.demo.MyServlet

Se o comando retornar uma observação sobre a implantação de instâncias, ainda será possível prosseguir e executar a próxima atualização, mas a última talvez ainda não esteja visível na instância.

Mostrar histórico de implantação show-deployment-history

Você pode verificar o histórico de implantações feitas no RDE executando:

aio aem:rde:history

Que retorna uma resposta na forma de:

#1: deploy completed for content-package aem-guides-wknd.all-2.1.0.zip on author,publish - done by 029039A55D4DE16A0A494025@AdobeID at 2022-09-12T14:41:55.393Z

Excluir do RDE deleting-from-rde

Você pode usar as ferramentas da CLI para excluir configurações e pacotes implantados anteriormente no RDE. Use o comando status para obter uma lista do que pode ser excluído, que inclui bsn para pacotes e pid para configurações a serem referenciadas no comando delete.

Por exemplo, se com.adobe.granite.demo.MyServlet.cfg.json foi instalado, o bsn é apenas com.adobe.granite.demo.MyServlet, sem o sufixo cfg.json.

Não há suporte para a exclusão de pacotes de conteúdo ou arquivos de conteúdo. Para removê-los, redefina o RDE, que o retorna ao estado padrão.

Consulte o exemplo abaixo para obter mais detalhes:

aio aem:rde:delete com.adobe.granite.csrf.impl.CSRFFilter
#13: delete completed for osgi-config com.adobe.granite.csrf.impl.CSRFFilter on author - done by karl at 2022-09-12T22:01:01.955Z
#14: delete completed for osgi-config com.adobe.granite.csrf.impl.CSRFFilter on publish - done by karl at 2022-09-12T22:01:12.979Z

Para obter mais informações e demonstração, consulte o tutorial em vídeo como usar comandos RDE (10:01).

Implantar em um RDE a partir de provedores Git externos deploy-to-rde

A Cloud Manager oferece suporte à implantação de código em um RDE diretamente de provedores Git externos ao usar a configuração BYOG (Bring Your Own Git).

A implantação em RDEs de um repositório Git externo requer o seguinte:

Notas de uso

Como funciona

Logs rde-logging

Semelhante a outros tipos de ambiente, os níveis de log podem ser definidos modificando as configurações do OSGi, embora, conforme descrito acima, o modelo de implantação para RDEs envolva uma linha de comando em vez de uma implantação do Cloud Manager. Consulte a documentação de log para obter mais informações sobre como exibir, baixar e interpretar logs.

A CLI do RDE também tem seu próprio comando log, usado para configurar rapidamente quais classes e pacotes são registrados e em que nível de log. Essas configurações podem ser visualizadas como efêmeras, pois não modificam as propriedades OSGI no controle de versão. Esse recurso tem como foco rastrear logs em tempo real, em vez de pesquisar logs de um passado distante.

O exemplo a seguir ilustra como rastrear a camada do autor, com um pacote definido para um nível de log de depuração e dois pacotes (separados por espaços) definidos para um nível de depuração de informações. A saída que inclui um pacote auth está realçada.

aio aem:rde:logs --target=author --debug=org.apache.sling --info=org.apache.sling.commons.threads.impl org.apache.sling.jcr.resource.internal.helper.jcr -H .auth.

aio aem:rde:reset

Consulte aio aem:rde:logs --help para obter o conjunto completo de opções de linha de comando.

Os recursos incluem o seguinte:

Observe que os registros são armazenados na memória no RDE e esses registros são reciclados e, portanto, descartados se não forem descartados ou se a rede for muito lenta.

Redefinir o RDE reset-rde

A redefinição do RDE remove todos os códigos personalizados, configurações e conteúdo das instâncias do autor e de publicação. A redefinição do RDE é útil quando você conclui o teste de um recurso e deseja retornar o ambiente para um estado padrão antes de testar outro.

Uma redefinição define o RDE para a versão mais recente do AEM disponível.

Você pode redefinir o RDE usando Cloud Manager ou a linha de comando. A redefinição leva alguns minutos e todo o conteúdo e código existente é excluído do RDE.

Redefina o RDE usando a linha de comando reset-the-rde-command-line

Você pode redefinir o RDE e retorná-lo a um estado padrão executando o seguinte:

aio aem:rde:reset

Esse processo geralmente leva alguns minutos e relata Environment reset. quando bem-sucedido ou Failed to reset the environment. sobre erros. Para uma saída estruturada, consulte o capítulo sobre a saída --json abaixo.

Use o comando de status para verificar quando o ambiente está pronto novamente.

Redefina o RDE no Cloud Manager reset-the-rde-cloud-manager

Você pode usar o Cloud Manager para redefinir seu RDE seguindo as etapas abaixo:

Depois que a redefinição do RDE é iniciada, geralmente leva alguns minutos para ser concluída e restaurar o ambiente ao seu estado padrão. Você pode exibir o status de redefinição a qualquer momento na coluna Status do cartão ou janela Ambientes.

Você também pode redefinir o RDE usando o botão de reticências diretamente do cartão Ambientes na página Visão geral.

Para obter mais informações sobre como usar o Cloud Manager para gerenciar seus ambientes, consulte a documentação do Cloud Manager.

Comandos que oferecem suporte à saída JSON json-commands

A maioria dos comandos dá suporte ao sinalizador global --json que suprime a saída do console e retorna um json válido para ser processado em scripts. Abaixo estão alguns comandos compatíveis, com exemplos da saída json.

Status status

{
  "programId": "myProgram",
  "environmentId": "myEnv",
  "status": "Modification in progress | Deployment in progress | Upload in progress | Ready (instances are currently deploying) | Ready",
  "author": {
    "osgiBundles": [],
    "osgiConfigs": []
  },
  "publish": {
    "osgiBundles": [],
    "osgiConfigs": []
  }
}

{
  "programId": "myProgram",
  "environmentId": "myEnv",
  "status": "Ready",
  "author": {
    "osgiBundles": [
      {
        "id": "author_osgi-bundle_com.adobe.granite.hotdev.demo",
        "updateId": "80",
        "service": "author",
        "type": "osgi-bundle",
        "metadata": {
          "name": "hotdev.demo.ui.apps.all-1.0.0-SNAPSHOT.zip",
          "bundleSymbolicName": "com.adobe.granite.hotdev.demo",
          "bundleName": "HotDev Bundle",
          "bundleVersion": "1.0.0.SNAPSHOT"
        }
      }
    ],
    "osgiConfigs": [
      {
        "id": "publish_osgi-config_com.adobe.granite.demo.MyServlet",
        "updateId": "80",
        "service": "publish",
        "type": "osgi-config",
        "metadata": {
          "name": "hotdev.demo.ui.apps.all-1.0.0-SNAPSHOT.zip",
          "configPid": "com.adobe.granite.demo.MyServlet"
        }
      }
    ]
  },
  "publish": {
    "osgiBundles": [
      {
        "id": "author_osgi-bundle_com.adobe.granite.hotdev.demo",
        "updateId": "80",
        "service": "author",
        "type": "osgi-bundle",
        "metadata": {
          "name": "hotdev.demo.ui.apps.all-1.0.0-SNAPSHOT.zip",
          "bundleSymbolicName": "com.adobe.granite.hotdev.demo",
          "bundleName": "HotDev Bundle",
          "bundleVersion": "1.0.0.SNAPSHOT"
        }
      }
    ],
    "osgiConfigs": [
      {
        "id": "publish_osgi-config_com.adobe.granite.demo.MyServlet",
        "updateId": "80",
        "service": "publish",
        "type": "osgi-config",
        "metadata": {
          "name": "hotdev.demo.ui.apps.all-1.0.0-SNAPSHOT.zip",
          "configPid": "com.adobe.granite.demo.MyServlet"
        }
      }
    ]
  }
}

Instalar install

{
  "programId": "myProgram",
  "environmentId": "myEnv",
  "items": [
    {
      "updateId": "4",
      "info": "deploy",
      "action": "deploy",
      "metadata": {
        "name": "hotdev.demo.ui.apps.all-1.0.0-SNAPSHOT.zip"
      },
      "services": [
        "author",
        "publish"
      ],
      "status": "completed",
      "timestamps": {
        "received": "2024-05-21T12:30:44.578Z",
        "processed": "2024-05-21T12:31:07.886468Z"
      },
      "user": "userId",
      "type": "content-package",
      "hash": "2ad73507",
      "logs": [
        "No logs available for this update."
      ]
    }
  ]
}

Excluir delete

{
  "programId": "myProgram",
  "environmentId": "myEnv",
  "items": [
    {
      "updateId": "84",
      "info": "delete author_osgi-bundle_com.adobe.granite.hotdev.demo",
      "action": "delete",
      "metadata": {},
      "services": [
        "author"
      ],
      "status": "completed",
      "timestamps": {
        "received": "2024-05-21T11:49:16.889Z",
        "processed": "2024-05-21T11:49:18.188420Z"
      },
      "user": "userId",
      "type": "osgi-bundle",
      "deletedArtifact": {
        "id": "author_osgi-bundle_com.adobe.granite.hotdev.demo",
        "metadata": {
          "name": "hotdev.demo.ui.apps.all-1.0.0-SNAPSHOT.zip",
          "bundleSymbolicName": "com.adobe.granite.hotdev.demo",
          "bundleName": "HotDev Bundle",
          "bundleVersion": "1.0.0.SNAPSHOT"
        },
        "service": "author",
        "type": "osgi-bundle",
        "updateId": "83"
      },
      "hash": "636f6d2e",
      "logs": [
        "No logs available for this update."
      ]
    },
    {
      "updateId": "85",
      "info": "delete publish_osgi-bundle_com.adobe.granite.hotdev.demo",
      "action": "delete",
      "metadata": {},
      "services": [
        "publish"
      ],
      "status": "completed",
      "timestamps": {
        "received": "2024-05-21T11:49:23.857Z",
        "processed": "2024-05-21T11:49:25.237930Z"
      },
      "user": "userId",
      "type": "osgi-bundle",
      "deletedArtifact": {
        "id": "publish_osgi-bundle_com.adobe.granite.hotdev.demo",
        "metadata": {
          "name": "hotdev.demo.ui.apps.all-1.0.0-SNAPSHOT.zip",
          "bundleSymbolicName": "com.adobe.granite.hotdev.demo",
          "bundleName": "HotDev Bundle",
          "bundleVersion": "1.0.0.SNAPSHOT"
        },
        "service": "publish",
        "type": "osgi-bundle",
        "updateId": "83"
      },
      "hash": "636f6d2e",
      "logs": [
        "No logs available for this update."
      ]
    }
  ]
}

Histórico history

{
  "programId": "myProgram",
  "environmentId": "myEnv",
  "status": "Ready",
  "items": [
    {
      "updateId": "112",
      "info": "delete publish_osgi-bundle_com.adobe.granite.hotdev.demo",
      "action": "delete",
      "metadata": {},
      "services": [
        "publish"
      ],
      "status": "completed",
      "timestamps": {
        "received": "2024-05-21T12:53:07.934Z",
        "processed": "2024-05-21T12:53:09.118766Z"
      },
      "user": "userId",
      "type": "osgi-bundle",
      "deletedArtifact": {
        "id": "publish_osgi-bundle_com.adobe.granite.hotdev.demo",
        "metadata": {
          "name": "hotdev.demo.ui.apps.all-1.0.0-SNAPSHOT.zip",
          "bundleSymbolicName": "com.adobe.granite.hotdev.demo",
          "bundleName": "HotDev Bundle",
          "bundleVersion": "1.0.0.SNAPSHOT"
        },
        "service": "publish",
        "type": "osgi-bundle",
        "updateId": "110"
      },
      "hash": "636f6d2e"
    },
    {
      "updateId": "111",
      "info": "delete author_osgi-bundle_com.adobe.granite.hotdev.demo",
      "action": "delete",
      "metadata": {},
      "services": [
        "author"
      ],
      "status": "completed",
      "timestamps": {
        "received": "2024-05-21T12:53:00.824Z",
        "processed": "2024-05-21T12:53:02.101560Z"
      },
      "user": "userId",
      "type": "osgi-bundle",
      "deletedArtifact": {
        "id": "author_osgi-bundle_com.adobe.granite.hotdev.demo",
        "metadata": {
          "name": "hotdev.demo.ui.apps.all-1.0.0-SNAPSHOT.zip",
          "bundleSymbolicName": "com.adobe.granite.hotdev.demo",
          "bundleName": "HotDev Bundle",
          "bundleVersion": "1.0.0.SNAPSHOT"
        },
        "service": "author",
        "type": "osgi-bundle",
        "updateId": "110"
      },
      "hash": "636f6d2e"
    },
    {
      "updateId": "110",
      "info": "deploy",
      "action": "deploy",
      "metadata": {
        "name": "hotdev.demo.ui.apps.all-1.0.0-SNAPSHOT.zip"
      },
      "services": [
        "author",
        "publish"
      ],
      "status": "completed",
      "timestamps": {
        "received": "2024-05-21T12:52:12.123Z",
        "processed": "2024-05-21T12:52:31.026147Z"
      },
      "user": "userId",
      "type": "content-package",
      "hash": "2ad73507"
    }
  ]
}

Redefinir reset

{
  "programId": "myProgram",
  "environmentId": "myEnv",
  "status": "resetting"
}

{
  "programId": "myProgram",
  "environmentId": "myEnv",
  "status": "reset"
}

{
  "programId": "myProgram",
  "environmentId": "myEnv",
  "status": "reset_failed"
}

Reiniciar restart

{
  "programId": "myProgram",
  "environmentId": "myEnv",
  "status": "restarted"
}

Modos de execução runmodes

A configuração OSGI específica para RDE pode ser aplicada usando sufixos no nome da pasta, como nos exemplos abaixo:

Consulte a documentação do modo de execução para obter informações gerais sobre modos de execução.

Os RDEs são distintos de outros ambientes, pois o conteúdo pode ser instalado em uma pasta install.rde (ou install.author.rde ou install.publish.rde) em /apps. Essa capacidade permite confirmar o conteúdo no Git e entregá-lo ao RDE usando a ferramenta de linha de comando.

Preencher com conteúdo populating-content

Quando um RDE é redefinido, todo o conteúdo é removido e, portanto, se desejado, uma ação explícita deve ser tomada para adicionar conteúdo. Como prática recomendada, considere montar um conjunto de conteúdo a ser usado como conteúdo de teste para validar ou depurar recursos no RDE. Há várias estratégias possíveis para preencher o RDE com esse conteúdo:

Você está limitado a 1 GB ao sincronizar pacotes de conteúdo.

Em que os RDEs são diferentes dos ambientes de desenvolvimento em nuvem? how-are-rds-different-from-cloud-development-environments

Embora o RDE seja, de muitas maneiras, semelhante a um ambiente de desenvolvimento na nuvem, há algumas pequenas diferenças arquitetônicas para permitir a sincronização rápida do código. O mecanismo para obter o código para o RDE é diferente — para RDEs, um sincroniza o código de um ambiente de desenvolvimento local, enquanto para ambientes de desenvolvimento em nuvem, um implanta o código por meio do Cloud Manager.

Por esses motivos, recomenda-se que, após validar o código em um ambiente RDE, você implante o código em um ambiente de desenvolvimento na nuvem usando o pipeline de não produção. Por fim, teste o código antes de implantar com o pipeline de produção.

Observe também as seguintes considerações:

De quantos RDEs preciso? how-many-rds-do-i-need

Uma RDE está disponível para cada solução licenciada e a Adobe também oferece RDEs adicionais, que podem ser licenciados para programas de produção (que não sejam de sandbox).

O número de RDEs necessários depende da composição e dos processos de uma organização. O modelo mais flexível é quando uma organização compra uma RDE dedicada para cada um de seus desenvolvedores do AEM Cloud Service. Neste modelo, cada desenvolvedor pode testar seu código no RDE sem coordenar com outros membros da equipe sobre se um ambiente RDE está disponível.

No outro extremo, uma equipe com apenas uma RDE pode contar com a coordenação interna para decidir qual desenvolvedor utiliza o ambiente num determinado momento. Essa abordagem funciona bem quando um desenvolvedor atinge um marco de recursos e precisa validar seu trabalho em um ambiente de nuvem com a flexibilidade para fazer alterações rápidas.

Um modelo intermediário é aquele em que uma organização compra vários RDEs, de modo que há uma maior probabilidade de um RDE não utilizado estar disponível. Uma estratégia poderia ser alocar um RDE por equipe de scrum ou recurso principal. Processos internos podem ser usados para coordenar o uso dos ambientes.

Como um RDE do AEM Forms Cloud Service é diferente de outros ambientes? how-are-forms-rds-different-from-cloud-development-environments

Os desenvolvedores da Forms podem usar o AEM Forms Cloud Service Rapid Development Environment para desenvolver rapidamente o Forms adaptável, workflows e personalizações, como a personalização de componentes principais, integrações com sistemas de terceiros e muito mais. O AEM Forms Cloud Service Rapid Development Environment (RDE) não é compatível com APIs de comunicação. Ele também não tem suporte para recursos e funcionalidades que exigem o Documento de registro, como gerar um Documento de registro no envio de um Formulário adaptável. Os recursos do AEM Forms listados abaixo não estão disponíveis em um Ambiente de desenvolvimento rápido (RDE):

Tutorial RDE

Para saber mais sobre o RDE no AEM as a Cloud Service, veja o tutorial em vídeo que demonstra como configurá-lo, como usá-lo e o ciclo de vida do desenvolvimento (01:25).

Solução de problemas troubleshooting

Solução de problemas de RDE (#rde-troublehooting)

Como obter a versão mais recente do AEM para um RDE existente get-latest-aem-version

Após a criação, os RDEs são definidos para a versão mais recente do Adobe Experience Manager (AEM). Uma redefinição de RDE, que pode ser executada usando o Cloud Manager ou o comando aio aem:rde:reset, circula o RDE e o define para a versão do AEM mais recente disponível.

Solução de problemas do plug-in aio RDE aio-rde-plugin-troubleshooting

Erros relacionados a permissões insuficientes insufficient-permissions

Para usar o plug-in RDE, é necessário que você seja membro do Perfil de Produto Desenvolvedor - Cloud Service do Cloud Manager. Consulte Atribuir membros da equipe a perfis de produto do Cloud Manager - Atribuir o perfil de produto do desenvolvedor para obter mais detalhes.

Como alternativa, você pode confirmar que tem essa função de desenvolvedor se fizer logon no console do desenvolvedor executando o seguinte comando:

aio cloudmanager:environment:open-developer-console

aio plugins:install @adobe/aio-cli-plugin-cloudmanager

Verifique se o logon foi concluído com êxito executando o seguinte:

aio cloudmanager:list-programs

Esse processo lista todos os programas na organização configurada e confirma que a função correta foi atribuída a você.

Usar contexto obsoleto aio-cli-plugin-cloudmanager aio-rde-plugin-troubleshooting-deprecatedcontext

Devido ao histórico do aio-cli-plugin-aem-rde, o nome de contexto aio-cli-plugin-cloudmanager foi usado por algum tempo. O plug-in RDE agora usa o método IMS para gerenciar informações de contexto, permitindo que você armazene contexto global ou localmente. Você também pode configurar um contexto padrão para aplicar a todas as chamadas AIO automaticamente. O contexto padrão configurado é armazenado localmente e permite que os desenvolvedores rastreiem e usem contextos individuais e suas informações dentro de uma pasta. Para obter mais detalhes, leia o exemplo para configurar um contexto local acima.

Os desenvolvedores que usam ambos os plug-ins, o aio-cli-plugin-cloudmanager e o aio-cli-plugin-aem-rde e que gostariam de manter todas as informações no mesmo contexto, têm duas opções agora:

Continuar usando o contexto aio-cli-plugin-cloudmanager

O contexto ainda pode ser usado. Um aviso de desativação é mostrado no plug-in RDE. Este aviso pode ser omitido usando o modo --quiet. As versões mais recentes do plug-in RDE não oferecem mais o fallback para ler o contexto aio-cli-plugin-cloudmanager. Para continuar a usá-lo, basta configurar o contexto padrão para aio-cli-plugin-cloudmanager. Consulte o exemplo para configurar um contexto local acima.

Use qualquer outro nome de contexto também para o plug-in do Cloud Manager

Os plug-ins do Cloud Manager oferecem um parâmetro para definir um contexto a ser usado. Ainda não há suporte para a configuração de contexto padrão IMS. Para fazer isso, configure o plug-in RDE usando o exemplo para definir um contexto local e instruir o plug-in Cloud Manager a usar myContext como --imsContextName=myContext em cada chamada para ele.