Saiba como usar Fragmentos de conteúdo no Adobe Experience Manager (AEM) com a API GraphQL AEM para entrega de conteúdo sem interface.
A API GraphQL do AEM utilizada com Fragmentos de conteúdo é baseada na API GraphQL padrão de código aberto.
Usar a API GraphQL no AEM permite a entrega eficiente dos Fragmentos de conteúdo aos clientes JavaScript em implementações CMS headless:
O GraphQL é usado atualmente em dois cenários (separados) no Adobe Experience Manager (AEM):
O GraphQL é:
"…um idioma de consulta para APIs e um tempo de execução para realizar essas consultas com seus dados existentes. O GraphQL fornece uma descrição completa e compreensível dos dados em sua API, concede aos clientes nada além do poder de solicitar exatamente o que precisam, facilita a evolução das APIs ao longo do tempo e habilita ferramentas avançadas de desenvolvedor.".
Consulte GraphQL.org
"…uma especificação aberta para uma camada de API flexível. Coloque o GraphQL sobre seus back-end existentes para criar produtos mais rápido do que nunca…".
Consulte Explorar GraphQL.
"…uma linguagem de consulta de dados e especificação desenvolvidas internamente pelo Facebook em 2012, antes de serem disponibilizadas publicamente em 2015. Ele oferece uma alternativa às arquiteturas baseadas em REST, com o objetivo de aumentar a produtividade do desenvolvedor e minimizar as quantidades de dados transferidos. O GraphQL é usado na produção por centenas de organizações de todos os tamanhos…"
Consulte Fundação GraphQL.
Para obter mais informações sobre a API GraphQL, consulte as seguintes seções (entre muitos outros recursos):
Em graphql.org:
Em graphql.com:
A implementação do GraphQL para AEM é baseada na Biblioteca GraphQL Java padrão. Consulte:
O GraphQL usa o seguinte:
O caminho no AEM que responde a consultas de GraphQL e fornece acesso aos esquemas de GraphQL.
Consulte Habilitação do endpoint de GraphQL para obter mais detalhes.
Consulte a Introdução ao GraphQL (GraphQL.org) para obter detalhes abrangentes, incluindo as Práticas recomendadas.
Com o GraphQL, é possível executar consultas para retornar:
Uma entrada única
Também é possível executar:
É possível testar e depurar consultas de GraphQL usando o IDE GraphiQL.
O endpoint é o caminho usado para acessar o GraphQL no AEM. Usando esse caminho, você (ou seu aplicativo) pode:
Há dois tipos de endpoints no AEM:
O Editor de fragmento de conteúdo pode permitir que um fragmento de conteúdo de uma configuração do Sites faça referência a um fragmento de conteúdo de outra configuração do Sites (por meio de políticas).
Nesse caso, nem todo o conteúdo poderá ser recuperado usando um endpoint específico de uma configuração do Sites.
O autor de conteúdo deve controlar esse cenário; por exemplo, pode ser útil considerar colocar modelos de fragmento de conteúdo compartilhados na configuração global do Sites.
O caminho do repositório do GraphQL para o endpoint global do AEM é:
/content/cq:graphql/global/endpoint
Para o qual seu aplicativo pode usar o seguinte caminho no URL da solicitação:
/content/_cq_graphql/global/endpoint.json
Para habilitar um endpoint para GraphQL no AEM, é necessário:
Para habilitar um endpoint de GraphQL, primeiro é necessário ter uma configuração apropriada. Consulte Fragmentos de conteúdo - Navegador de configuração.
Se o uso de modelos de fragmento de conteúdo não foi habilitado, a opção Criar não estará disponível.
Para habilitar o endpoint correspondente:
Navegue até Ferramentas, Ativos e, em seguida, selecione GraphQL.
Selecione Criar.
A caixa de diálogo Criar novo endpoint de GraphQL será aberta. Aqui, é possível especificar:
O seguinte aviso é mostrado na caixa de diálogo:
Confirme com Criar.
A caixa de diálogo Próximas etapas fornecerá um link direto até o console de Segurança, para que você possa garantir que o endpoint recém-criado tenha as permissões adequadas.
O endpoint é acessível a todos. Isso pode causar uma preocupação de segurança, especialmente em instâncias de publicação, já que as consultas de GraphQL podem colocar uma carga pesada sobre o servidor.
É possível configurar ACLs apropriadas ao seu caso de uso no endpoint.
Selecione o novo endpoint e escolha Publicar para disponibilizá-lo completamente, em todos os ambientes.
O endpoint é acessível a todos.
Isso pode causar uma preocupação de segurança em instâncias de publicação, já que as consultas de GraphQL podem colocar uma carga pesada sobre o servidor.
Você deve configurar ACLs apropriadas ao seu caso de uso no endpoint.
Uma implementação do padrão GraphiQL A interface do está disponível para uso com AEM GraphQL. Pode ser instalado com o AEM.
O GraphiQL está vinculado ao endpoint global (e não funciona com outros endpoints para configurações específicas do Sites).
Essa interface permite que você insira e teste diretamente consultas.
Por exemplo:
http://localhost:4502/content/graphiql.html
Isso fornece recursos como realce de sintaxe, preenchimento automático e sugestão automática, juntamente com um histórico e uma documentação online:
A interface do usuário GraphiQL pode ser instalada no AEM com um pacote dedicado: o Pacote de Conteúdo GraphiQL v0.0.6 (2021.3) pacote.
O pacote disponível é totalmente compatível com AEM 6.5.10.0 e AEM as a Cloud Service.
Os casos de uso podem depender do tipo de ambiente de AEM:
Ambiente de publicação; usado para:
Ambiente de autor; usado para:
As permissões são as necessárias para acessar o Assets.
O GraphQL é uma API altamente tipificada, o que significa que os dados devem ser estruturados e organizados claramente por tipo.
A especificação GraphQL fornece uma série de diretrizes sobre como criar uma API robusta para interrogar dados em uma determinada instância. Para fazer isso, um cliente precisa buscar o Esquema, que contém todos os tipos necessários para uma consulta.
Para fragmentos de conteúdo, os esquemas de GraphQL (estrutura e tipos) são baseados em modelos de fragmento de conteúdo habilitados e seus tipos de dados.
Todos os esquemas de GraphQL (derivados dos modelos de fragmento de conteúdo que foram Habilitados) são legíveis por meio do endpoint do GraphQL.
Isso significa que você precisa garantir que não haja dados confidenciais disponíveis, pois eles poderiam ser vazados dessa maneira; por exemplo, isso inclui informações que podem estar presentes como nomes de campo na definição do modelo.
Por exemplo, se um usuário criou um modelo de fragmento de conteúdo chamado Article
, então o AEM irá gerar o objeto article
, que é do tipo ArticleModel
. Os campos desse tipo correspondem aos campos e tipos de dados definidos no modelo.
Um modelo de fragmento de conteúdo:
O esquema de GraphQL correspondente (saída da documentação automática do GraphiQL):
Isso mostra que o tipo gerado ArticleModel
contém vários campos.
Três deles foram controlados pelo usuário: author
, main
e referencearticle
.
Os outros campos foram adicionados automaticamente pelo AEM e representam métodos úteis para fornecer informações sobre um determinado fragmento de conteúdo; neste exemplo, _path
, _metadata
e _variations
. Esses campos auxiliares estão marcados com um _
precedente, para distinguir entre o que foi definido pelo usuário e o que foi gerado automaticamente.
Depois que um usuário cria um fragmento de conteúdo com base no modelo de Artigo, ele pode ser interrogado por meio do GraphQL. Para obter exemplos, consulte Exemplos de consulta (baseado em uma amostra da estrutura do fragmento de conteúdo para uso com GraphQL).
No GraphQL para AEM, o esquema é flexível. Isso significa que ele é gerado automaticamente toda vez que um modelo de fragmento de conteúdo é criado, atualizado ou excluído. Os caches do esquema de dados também são atualizados quando você atualiza um modelo de fragmento de conteúdo.
O serviço GraphQL do Sites acompanha (em segundo plano) quaisquer modificações feitas em um modelo de fragmento de conteúdo. Quando as atualizações são detectadas, somente essa parte do esquema é gerada novamente. Essa otimização economiza tempo e oferece estabilidade.
Por exemplo, se você:
Instalar um pacote contendo Content-Fragment-Model-1
e Content-Fragment-Model-2
:
Model-1
e Model-2
serão gerados.Em seguida, o Content-Fragment-Model-2
é modificado:
Somente o tipo de GraphQL para Model-2
será atualizado.
Já o Model-1
permanecerá o mesmo.
É importante observar isso caso queira fazer atualizações em massa nos modelos de fragmento de conteúdo por meio da API REST ou de outra maneira.
O esquema é distribuído por meio do mesmo endpoint das consultas de GraphQL, com o cliente lidando com o fato de que o esquema é chamado com a extensão GQLschema
. Por exemplo, executar uma simples solicitação GET
em /content/cq:graphql/global/endpoint.GQLschema
resultará na saída do esquema com o tipo do conteúdo: text/x-graphql-schema;charset=iso-8859-1
.
Quando os fragmentos de conteúdo são aninhados, pode acontecer que um modelo de fragmento de conteúdo principal seja publicado, mas um modelo referenciado não.
A interface do AEM impede que isso aconteça, mas se a publicação for feita de maneira programática ou com pacotes de conteúdo, isso poderá ocorrer.
Quando isso acontece, o AEM gera um esquema incompleto do modelo de fragmento de conteúdo principal. Isso significa que a referência do fragmento, que depende do modelo não publicado, é removida do esquema.
Dentro do esquema há campos individuais de duas categorias básicas:
Campos gerados.
Uma seleção de Tipos de campos é usada para criar campos com base em como você configura o modelo de fragmento de conteúdo. Os nomes de campo são retirados do campo Nome da propriedade do Tipo de dados.
O GraphQL do AEM também gera vários campos auxiliares.
Eles são usados para identificar um fragmento de conteúdo ou obter mais informações sobre ele.
O GraphQL do AEM oferece suporte a uma lista de tipos. Todos os tipos de dados do modelo de fragmento de conteúdo compatíveis e os tipos de GraphQL correspondentes são representados:
Modelo de fragmento de conteúdo - Tipo de dados | Tipo de GraphQL | Descrição |
---|---|---|
Texto em linha única | Sequência de caracteres, [Sequência de caracteres] | Usado para sequências de caracteres simples, como nomes de autor, nomes de localização etc. |
Texto multilinha | Sequência de caracteres | Usado para saída de texto, como o corpo de um artigo |
Número | Flutuante, [Flutuante] | Usado para exibir números de ponto flutuantes e números regulares |
Booleano | Booleano | Usado para exibir caixas de seleção → declarações simples de verdadeiro/falso |
Data e hora | Calendário | Usado para exibir data e hora em um formato ISO 8086. Dependendo do tipo selecionado, há três opções disponíveis para uso no GraphQL do AEM: onlyDate , onlyTime e dateTime |
Enumeração | Sequência de caracteres | Usado para exibir uma opção de uma lista de opções definidas na criação do modelo |
Tags | [Sequência de caracteres] | Usado para exibir uma lista de sequências de caracteres que representam tags usadas no AEM |
Referência de conteúdo | Sequência de caracteres | Usado para exibir o caminho para outro ativo no AEM |
Referência do fragmento | Um tipo de modelo | Usado para fazer referência a outro Fragmento de conteúdo de um determinado Tipo de modelo, definido quando o modelo foi criado |
Além dos tipos de dados para campos gerados pelo usuário, o GraphQL para AEM também gera vários campos auxiliares para ajudar a identificar um Fragmento de conteúdo ou fornecer informações adicionais sobre um Fragmento de conteúdo.
O campo de caminho é usado como um identificador no GraphQL. Ele representa o caminho do ativo Fragmento de conteúdo dentro do repositório do AEM. Escolhemos isso como o identificador de um fragmento de conteúdo, pois ele:
O código a seguir exibirá os caminhos de todos os Fragmentos de conteúdo que foram criados com base no Modelo de fragmento de conteúdo Person
.
{
personList {
items {
_path
}
}
}
Para recuperar um único Fragmento de conteúdo de um tipo específico, também é necessário determinar seu caminho primeiro. por exemplo:
{
personByPath(_path: "/content/dam/path/to/fragment/john-doe") {
item {
_path
firstName
name
}
}
}
Consulte Exemplo de consulta - um único fragmento específico de cidade.
Por meio do GraphQL, o AEM também expõe os metadados de um Fragmento de conteúdo. Metadados são as informações que descrevem um fragmento de conteúdo, como o título de um fragmento de conteúdo, o caminho da miniatura, a descrição de um Fragmento de conteúdo, a data de criação, dentre outros.
Como os metadados são gerados por meio do Editor de esquemas e, como tal, não têm uma estrutura específica, o GraphQL tipo TypedMetaData
foi implementado para expor os metadados de um Fragmento de conteúdo. TypedMetaData
expõe as informações agrupadas pelos seguintes tipos escalares:
Texto |
---|
stringMetadata:[StringMetadata]! |
stringArrayMetadata:[StringArrayMetadata]! |
intMetadata:[IntMetadata]! |
intArrayMetadata:[IntArrayMetadata]! |
floatMetadata:[FloatMetadata]! |
floatArrayMetadata:[FloatArrayMetadata]! |
booleanMetadata:[BooleanMetadata]! |
booleanArrayMetadata:[booleanArrayMetadata]! |
calendarMetadata:[CalendarMetadata]! |
calendarArrayMetadata:[CalendarArrayMetadata]! |
Cada tipo escalar representa um único par de nome-valor ou uma matriz de pares de nome-valor, em que o valor desse par é do tipo em que foi agrupado.
Por exemplo, se você quiser recuperar o título de um Fragmento de conteúdo, sabemos que essa é uma propriedade de String; portanto, consultaríamos todos os metadados de String:
Para consultar metadados:
{
personByPath(_path: "/content/dam/path/to/fragment/john-doe") {
item {
_path
_metadata {
stringMetadata {
name
value
}
}
}
}
}
É possível exibir todos os tipos de metadados GraphQL, se você exibir o esquema GraphQL gerado. Todos os tipos de modelo têm o mesmo TypedMetaData
.
Diferença entre metadados normais e de matriz
Lembre-se que StringMetadata
e StringArrayMetadata
se referem ao que é armazenado no repositório, não a como você os recupera.
Por exemplo, ao chamar o campo stringMetadata
, você receberia uma matriz de todos os metadados que foram armazenados no repositório como um String
; e ao chamar stringArrayMetadata
, você receberia uma matriz de todos os metadados que foram armazenados no repositório como String[]
.
Consulte Exemplo de consulta para metadados - listar os metadados para prêmios denominados GB.
O campo _variations
foi implementado para simplificar a consulta das variações que um Fragmento de conteúdo possui. Por exemplo:
{
personByPath(_path: "/content/dam/path/to/fragment/john-doe") {
item {
_variations
}
}
}
Consulte Exemplo de consulta - todas as cidades com uma variável nomeada.
Se a variação especificada não existir para um Fragmento de conteúdo, a variação principal será retornada como padrão (substituta).
O GraphQL permite que as variáveis sejam colocadas na consulta. Para obter mais informações, é possível visualizar a documentação do GraphQL sobre variáveis.
Por exemplo, para obter todos os Fragmentos de conteúdo do tipo Article
que tenham uma variação específica, é possível especificar a variável variation
no GraphiQL.
### query
query GetArticlesByVariation($variation: String!) {
articleList(variation: $variation) {
items {
_path
author
}
}
}
### in query variables
{
"variation": "uk"
}
No GraphQL, há uma possibilidade de alterar a consulta com base em variáveis, chamadas de Diretivas GraphQL.
Por exemplo, é possível incluir o campo adventurePrice
em uma consulta para todos os AdventureModels
, com base em uma variável includePrice
.
### query
query GetAdventureByType($includePrice: Boolean!) {
adventureList {
items {
adventureTitle
adventurePrice @include(if: $includePrice)
}
}
}
### in query variables
{
"includePrice": true
}
Também é possível usar a filtragem em consultas de GraphQL para retornar dados específicos.
A filtragem usa uma sintaxe baseada em operadores lógicos e expressões.
Por exemplo, a consulta a seguir (básica) filtra todas as pessoas cujo nome é Jobs
ou Smith
:
query {
personList(filter: {
name: {
_logOp: OR
_expressions: [
{
value: "Jobs"
},
{
value: "Smith"
}
]
}
}) {
items {
name
firstName
}
}
}
Para obter mais exemplos, consulte:
detalhes da GraphQL para extensões do AEM
Exemplos de consulta usando esta amostra de conteúdo e estrutura
A operação básica de consultas com o GraphQL para AEM adere à especificação GraphQL padrão. Para consultas de GraphQL com o AEM, há algumas extensões:
Se você precisar de um único resultado:
Se você espera uma lista de resultados:
List
ao nome do modelo; por exemplo, cityList
O filtro includeVariations
está incluída no List
tipo de consulta. Para recuperar as variações do fragmento de conteúdo nos resultados da consulta, em seguida, use o includeVariations
deve ser definido como true
.
O filtro includeVariations
não pode ser usado junto com o campo gerado pelo sistema _variation
.
Se quiser usar um operador OR lógico:
_logOp: OR
O operador AND lógico também existe, mas está (muitas vezes) implícito
Você pode consultar nos nomes de campos que correspondem aos campos no modelo de fragmento de conteúdo
Além dos campos do modelo, há alguns campos gerados pelo sistema (precedidos por um sublinhado):
Para conteúdo:
_locale
: para revelar a língua; com base no Gerenciador de idiomas
_metadata
: para revelar metadados do fragmento
_model
: permite a consulta para um modelo de fragmento de conteúdo (caminho e título)
_path
: o caminho para o fragmento de conteúdo no repositório
_reference
: para revelar referências; incluindo referências em linha no Editor de Rich Text
_variation
: para revelar variações específicas no fragmento de conteúdo
Se a variação especificada não existir para um Fragmento de conteúdo, a variação principal será retornada como padrão (substituta).
O campo gerado pelo sistema _variation
não pode ser usado junto com o filtro includeVariations
.
_tags
: para revelar as IDs de Fragmentos de conteúdo ou Variações que contêm tags; isso é uma matriz de cq:tags
identificadores.
As tags também podem ser consultadas ao listar os metadados de um fragmento de conteúdo.
_operator
: aplica operadores específicos; EQUALS
, EQUALS_NOT
, GREATER_EQUAL
, LOWER
, CONTAINS
e STARTS_WITH
_apply
: para aplicar condições específicas; por exemplo, AT_LEAST_ONCE
_ignoreCase
: para ignorar se os caracteres são maiúsculos ou minúsculos ao consultar
Os tipos de união GraphQL são compatíveis:
Fazer o fallback ao consultar fragmentos aninhados:
Após preparar uma consulta com uma solicitação POST, ela pode ser executada com uma solicitação GET que pode ser armazenada em cache por caches HTTP ou um CDN.
Isso é necessário, pois as consultas do POST geralmente não são armazenadas em cache e, se estiver usando o GET com o query como parâmetro, há um risco significativo de o parâmetro se tornar muito grande para serviços HTTP e intermediários.
Consultas persistentes devem sempre usar o endpoint relacionado à configuração apropriada do Sites; para que possam usar um desses, ou ambos:
Consulte Habilitar a funcionalidade de fragmentos de conteúdo no Navegador de configuração para obter mais detalhes.
As Consultas de persistência GraphQL precisam estar habilitadas para a configuração apropriada do Sites.
Por exemplo, se houver uma consulta específica chamada my-query
, que usa um modelo my-model
da configuração my-conf
do Sites:
my-conf
e, em seguida, a consulta será salva da seguinte maneira:/conf/my-conf/settings/graphql/persistentQueries/my-query
global
, mas a consulta será salva da seguinte maneira:/conf/global/settings/graphql/persistentQueries/my-query
Essas são duas consultas diferentes - salvas em caminhos diferentes.
Por acaso, elas usam o mesmo modelo - mas por meio de diferentes endpoints.
Estas são as etapas necessárias para persistir uma determinada query:
Prepare a consulta utilizando o método PUT no novo URL do endpoint /graphql/persist.json/<config>/<persisted-label>
.
Por exemplo, crie uma consulta persistente:
$ curl -X PUT \
-H 'authorization: Basic YWRtaW46YWRtaW4=' \
-H "Content-Type: application/json" \
"http://localhost:4502/graphql/persist.json/wknd/plain-article-query" \
-d \
'{
articleList {
items{
_path
author
main {
json
}
}
}
}'
Neste ponto, verifique a resposta.
Por exemplo, verifique se há sucesso:
{
"action": "create",
"configurationName": "wknd",
"name": "plain-article-query",
"shortPath": "/wknd/plain-article-query",
"path": "/conf/wknd/settings/graphql/persistentQueries/plain-article-query"
}
Você pode repetir a consulta persistente ao obter o URL /graphql/execute.json/<shortPath>
.
Por exemplo, use a consulta persistente:
$ curl -X GET \
http://localhost:4502/graphql/execute.json/wknd/plain-article-query
Atualize uma consulta persistente utilizando o método POST em um caminho de consulta já existente.
Por exemplo, use a consulta persistente:
$ curl -X POST \
-H 'authorization: Basic YWRtaW46YWRtaW4=' \
-H "Content-Type: application/json" \
"http://localhost:4502/graphql/persist.json/wknd/plain-article-query" \
-d \
'{
articleList {
items{
_path
author
main {
json
}
referencearticle {
_path
}
}
}
}'
Crie uma consulta agrupada simples.
Por exemplo:
$ curl -X PUT \
-H 'authorization: Basic YWRtaW46YWRtaW4=' \
-H "Content-Type: application/json" \
"http://localhost:4502/graphql/persist.json/wknd/plain-article-query-wrapped" \
-d \
'{ "query": "{articleList { items { _path author main { json } referencearticle { _path } } } }"}'
Crie uma consulta agrupada simples com controle de cache.
Por exemplo:
$ curl -X PUT \
-H 'authorization: Basic YWRtaW46YWRtaW4=' \
-H "Content-Type: application/json" \
"http://localhost:4502/graphql/persist.json/wknd/plain-article-query-max-age" \
-d \
'{ "query": "{articleList { items { _path author main { json } referencearticle { _path } } } }", "cache-control": { "max-age": 300 }}'
Crie uma consulta persistente com parâmetros:
Por exemplo:
$ curl -X PUT \
-H 'authorization: Basic YWRtaW46YWRtaW4=' \
-H "Content-Type: application/json" \
"http://localhost:4502/graphql/persist.json/wknd/plain-article-query-parameters" \
-d \
'query GetAsGraphqlModelTestByPath($apath: String!, $withReference: Boolean = true) {
articleByPath(_path: $apath) {
item {
_path
author
main {
plaintext
}
referencearticle @include(if: $withReference) {
_path
}
}
}
}'
Execução de uma consulta com parâmetros.
Por exemplo:
$ curl -X POST \
-H 'authorization: Basic YWRtaW46YWRtaW4=' \
-H "Content-Type: application/json" \
"http://localhost:4502/graphql/execute.json/wknd/plain-article-query-parameters;apath=%2fcontent2fdam2fwknd2fen2fmagazine2falaska-adventure2falaskan-adventures;withReference=false"
$ curl -X GET \
"http://localhost:4502/graphql/execute.json/wknd/plain-article-query-parameters;apath=%2fcontent2fdam2fwknd2fen2fmagazine2falaska-adventure2falaskan-adventures;withReference=false"
Para executar o query na publicação, a árvore persistente relacionada precisa ser replicada
Uso de POST para replicação:
$curl -X POST http://localhost:4502/bin/replicate.json \
-H 'authorization: Basic YWRtaW46YWRtaW4=' \
-F path=/conf/wknd/settings/graphql/persistentQueries/plain-article-query \
-F cmd=activate
Uso de um pacote:
/conf/wknd/settings/graphql/persistentQueries
).Uso da ferramenta de replicação/distribuição.
/conf/wknd/settings/graphql/persistentQueries
).Uso de um fluxo de trabalho (por meio da configuração do iniciador do fluxo de trabalho):
Quando a configuração do query estiver em publicação, os mesmos princípios se aplicarão, apenas usando o endpoint de publicação.
Para acesso anônimo, o sistema assume que a ACL permite que “todos” tenham acesso à configuração da consulta.
Se esse não for o caso, não será possível executar.
Qualquer ponto e vírgula (";") nos URLs precisa ser codificado.
Por exemplo, como na solicitação para executar uma consulta persistente:
curl -X GET \ "http://localhost:4502/graphql/execute.json/wknd/plain-article-query-parameters%3bapath=%2fcontent2fdam2fwknd2fen2fmagazine2falaska-adventure2falaskan-adventures;withReference=false"
Para acessar o endpoint do GraphQL a partir de um site externo, é necessário configurar o:
Para obter uma visão geral detalhada da política de compartilhamento de recursos do CORS no AEM, consulte Entenda o CORS (Cross-Origin Resource Sharing, Compartilhamento de recursos entre origens).
Para acessar o ponto de extremidade GraphQL, uma política CORS deve ser configurada no repositório Git do cliente. Isso é feito adicionando um arquivo de configuração de CORS OSGi apropriado para os endpoints desejados.
Essa configuração deve especificar uma origem de site confiável alloworigin
ou alloworiginregexp
cujo acesso deve ser concedido.
Por exemplo, para conceder acesso ao endpoint do GraphQL e ao endpoint de consultas persistentes para https://my.domain
, é possível usar:
{
"supportscredentials":true,
"supportedmethods":[
"GET",
"HEAD",
"POST"
],
"exposedheaders":[
""
],
"alloworigin":[
"https://my.domain"
],
"maxage:Integer":1800,
"alloworiginregexp":[
""
],
"supportedheaders":[
"Origin",
"Accept",
"X-Requested-With",
"Content-Type",
"Access-Control-Request-Method",
"Access-Control-Request-Headers"
],
"allowedpaths":[
"/content/_cq_graphql/global/endpoint.json",
"/graphql/execute.json/.*"
]
}
Se você tiver configurado um caminho personalizado para o endpoint, também poderá usá-lo no allowedpaths
.
Além da configuração do CORS, um filtro Referenciador deve ser configurado para permitir acesso de hosts de terceiros.
Isso é feito adicionando um arquivo de configuração do Filtro de referenciador OSGi apropriado que:
allow.hosts
ou allow.hosts.regexp
Por exemplo, para conceder acesso a solicitações com o referenciador my.domain
, é possível:
{
"allow.empty":false,
"allow.hosts":[
"my.domain"
],
"allow.hosts.regexp":[
""
],
"filter.methods":[
"POST",
"PUT",
"DELETE",
"COPY",
"MOVE"
],
"exclude.agents.regexp":[
""
]
}
Continua a ser responsabilidade do cliente:
Toda os esquemas de GraphQL (derivados de modelos de fragmento de conteúdo que foram Habilitados) são legíveis por meio do endpoint do GraphQL.
Isso significa que você precisa garantir que não haja dados confidenciais disponíveis, pois eles poderiam ser vazados dessa maneira; por exemplo, isso inclui informações que podem estar presentes como nomes de campo na definição do modelo.
Consulte Autenticação para consultas de GraphQL remotas do AEM sobre fragmentos de conteúdo.
Perguntas que surgiram:
P: “Qual a diferença entre a API GraphQL do AEM e a API do Construtor de consultas?”
Procurando um tutorial prático? Veja o tutorial completo de Introdução ao AEM Headless e GraphQL que ilustra como criar e expor conteúdo usando as APIs GraphQL do AEM e consumi-lo por meio de um aplicativo externo, em um cenário de CMS headless.