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, o Adobe introduziu os RDEs (Rapid Development Environments, ambientes de desenvolvimento rápido).

As 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 reinicialização RDE, que pode ser executada usando Cloud Manager, circula o RDE e o configura para a versão AEM mais recente disponível.

Normalmente, um RDE seria 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

Siga estas etapas para poder usar o Cloud Manager para criar um RDE para seu programa.

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

Após a criação, os RDEs são definidos para a versão mais recente do AEM disponível. Uma redefinição de RDE, que também pode ser executada usando o Cloud Manager, circula o RDE e o configura para a versão AEM mais recente 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 a documentação do Cloud Manager.

Instalação das 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:

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

O comando setup perguntará 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

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 foi selecionado, uma lista de ambientes RDE é listada para escolher.
Caso haja apenas um programa e/ou ambiente RDE disponível, ele será selecionado automaticamente.

Para ver o contexto do ambiente atual, execute:

aio aem rde setup --show

O comando responderá com um resultado semelhante a:

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

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

Para ambientes em que nenhum usuário pode executar interativamente o comando de configuração conforme descrito acima (como CI/CD ou scripts), os três parâmetros para organização, programa e ambiente podem ser configurados manualmente de acordo com as etapas a seguir.

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:

Utilização do 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 que está sendo sincronizado com o RDE refletiria o rótulo do Git do que foi enviado para o ambiente em que o problema foi encontrado. Além disso, pode ser útil implantar o conteúdo correspondente ao ambiente de upstream. Isso pode ser feito 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 é para cada desenvolvedor confirmar as 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 de Ferramentas de Linha de Comando do RDE rde-cli-commands

Ajuda/Informações gerais help

Sinalizadores globais global-flags

Implantação no RDE deploying-to-rde

Esta seção descreve o uso da CLI do RDE para implantar, instalar ou atualizar pacotes, configurações OSGI, pacotes de conteúdo, arquivos de conteúdo individuais e configurações do Apache ou Dispatcher.

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 um nível específico.

Qualquer pacote 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

Implantação de 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

Implantação de 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 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.

Implantação da 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 principal 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 deve incluir o valor rde, como no exemplo abaixo:

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

Implantação de 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 com base em temas de site e modelos de site. Com RDEs, isso é feito usando uma diretiva de linha de comando para implantar pacotes de front-end, em vez do pipeline de front-end do Cloud Manager usado para outros tipos de ambiente.

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

npm run build

Ela deve gerar uma pasta dist/, de modo que a pasta do pacote front-end deve conter 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 de pacotes de front-end:

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

Verificação do 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.

Em execução:

aio aem:rde:status

Retorna 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

Excluindo do RDE deleting-from-rde

Você pode excluir configurações e pacotes que foram implantados anteriormente no RDE por meio das ferramentas da CLI. 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, o RDE deve ser redefinido, o 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).

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 de registro que pode ser usado para configurar rapidamente quais classes e pacotes devem ser registrados e em que nível de registro. 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:

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 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. Essa redefinição é útil, por exemplo, se o RDE tiver sido usado para testar um recurso específico e você quiser redefini-lo para um estado padrão para que você possa testar um recurso diferente.

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

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

Depois que o processo de redefinição do RDE é iniciado, ele geralmente leva alguns minutos para ser concluído e retornar o ambiente ao seu estado padrão. O status do processo de redefinição pode ser exibido a qualquer momento na coluna Status do cartão Ambientes ou na 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"
}

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. Isso 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 na nuvem? how-are-rds-different-from-cloud-development-environments

Embora o RDE seja, de muitas maneiras, semelhante a um ambiente de desenvolvimento em 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 de RDE, você implante o código em um Ambiente de desenvolvimento de 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

Um RDE está disponível para cada solução licenciada e o Adobe também oferece RDEs adicionais, que podem ser licenciados para programas de produção (não 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 um RDE dedicado 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 um único RDE pode usar processos internos para coordenar quais desenvolvedores podem usar o ambiente em um determinado momento. Possivelmente, isso acontece sempre que um desenvolvedor atinge um marco de recurso intermediário e está pronto para validar em um ambiente de nuvem, onde pode fazer rapidamente as alterações necessárias.

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 (Rapid Development Environment, ambiente de desenvolvimento rápido) da AEM Forms Cloud Service é diferente de outros ambientes? how-are-forms-rds-different-from-cloud-development-environments

Os desenvolvedores da Forms podem usar o Ambiente de desenvolvimento Cloud Service Rapid da AEM Forms para desenvolver rapidamente Forms adaptável, fluxos de trabalho e personalizações, como a personalização de componentes principais, integrações com sistemas de terceiros e muito mais. O RDE (Rapid Development Environment, ambiente de desenvolvimento rápido) da AEM Forms Cloud Service não é compatível com as 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).

​# Resolução de problemas

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 RDE, que pode ser executada usando o Cloud Manager ou o comando aio aem:rde:reset, desloca o RDE e o define para a versão AEM disponível mais recentemente.

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 Cloud Manager Developer - Cloud Service. 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 puder fazer logon no console do desenvolvedor executando este 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

aio cloudmanager:list-programs

Isso deve listar todos os programas na organização configurada e confirmar que você tem a função correta atribuída.

Uso do 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 a maneira IMS de lidar com informações de contexto, o que significa que há opções para armazenar informações de contexto global ou localmente, bem como padronizar todas as chamadas aio para um padrão configurado, se desejar. 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:

Continue usando o contexto "aio-cli-plugin-cloudmanager"

O contexto ainda pode ser usado, um aviso de desativação será 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 oferecerão mais o fallback para ler o contexto "aio-cli-plugin-cloudmanager". Para ainda fazer uso dele, basta configurar o contexto padrão como '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 configurar um contexto local e instrua o plug-in do Cloud Manager a usar 'myContext' como --imsContextName=myContext em cada chamada para ele.