Primeiros passos com Applications

Crie uma aplicação que envia toda requisição para a sua origem por um connector, entregue-a por um workload e faça uma requisição a ela.

Última atualização

Ver como Markdown Configurar agente

Este guia orienta você a entregar o conteúdo da sua origem pela sua primeira aplicação.

  • Crie um connector que alcança a sua origem por HTTPS.
  • Crie uma aplicação.
  • Adicione uma regra que envia toda requisição para o connector.
  • Entregue a aplicação por um workload.
  • Envie uma requisição para o domínio do workload e receba a resposta da sua origem.

Cinco partes formam a cadeia, listadas na ordem em que este guia as usa:

  1. O connector guarda o endereço da sua origem e a forma como a Azion se conecta a ela.
  2. A aplicação guarda as regras que decidem o que acontece com uma requisição. Uma aplicação nova não tem regras.
  3. A regra na aplicação combina um critério com um behavior. Neste guia, o critério corresponde a toda requisição, e o behavior Set Connector nomeia o connector.
  4. O workload guarda o domínio que recebe as requisições. O deployment dele nomeia a aplicação.
  5. A requisição para o domínio do workload encontra a regra, e o connector a passa para a sua origem.

Um connector só recebe requisições depois que uma regra o nomeia, e uma aplicação só depois que um deployment a nomeia.

Em uma aplicação, você habilita três Produtos: Cache, Application Accelerator e Image Processor. Uma aplicação nova começa com Cache ativado e os outros dois desativados, e este guia não altera nenhum deles. Para ativar um deles depois, abra a aba Main Settings da aplicação, ative o interruptor dele em Modules e selecione Save. Os primeiros passos de cada Produto começam onde este guia termina, com uma aplicação que já entrega conteúdo.

Os pré-requisitos e as cinco etapas mostram os passos de uma interface por vez. Selecione a sua:

Pré-requisitos

  • Uma conta Azion. Para mais informações, consulte Criar uma conta.
  • Um servidor de origem que responde a requisições HTTPS na porta 443 em um hostname público. Este guia escreve esse hostname como <your-origin-hostname>.
  • O curl, para enviar uma requisição pelo workload.

Você também precisa de acesso ao Azion Console. Para mais informações, consulte Como acessar o Azion Console.

Você também precisa da Azion CLI na sua máquina, autorizada com um personal token.

Você também precisa de um personal token para o header Authorization. Para criar um, consulte Como criar um personal token.

Crie um connector para a sua origem

Um connector guarda o endereço da sua origem e as configurações que a Azion usa para alcançá-la. Você o cria à parte, fora de qualquer aplicação, e uma regra o nomeia depois. Este connector tem um endereço e se conecta à sua origem por HTTPS. Ele envia o hostname da sua origem no header Host.

Para criar o connector pela Azion CLI, coloque-o primeiro em um arquivo JSON. Salve este corpo como connector.json e substitua <your-origin-hostname> nos dois lugares:

JSON
01{
02 "name": "origin-connector",
03 "type": "http",
04 "attributes": {
05 "addresses": [
06 { "address": "<your-origin-hostname>" }
07 ],
08 "connection_options": {
09 "transport_policy": "force_https",
10 "host": "<your-origin-hostname>"
11 }
12 }
13}

addresses lista os servidores de origem, e connection_options.host é o header Host que o connector envia. force_https faz toda conexão com a origem usar HTTPS.

Crie o connector a partir do arquivo:

azion create connector --file connector.json

Anote o ID do connector novo na saída do comando: a regra o passa como <connector-id>.

Para criar o connector pela API, envie uma requisição POST para o endpoint de connectors. Substitua [TOKEN VALUE] pelo seu personal token e <your-origin-hostname> pelo hostname da sua origem:

Shell
01curl --request POST \
02 --url https://api.azion.com/v4/workspace/connectors \
03 --header 'Accept: application/json' \
04 --header 'Authorization: Token [TOKEN VALUE]' \
05 --header 'Content-Type: application/json' \
06 --data {
07 "name": "origin-connector",
08 "type": "http",
09 "attributes": {
10 "addresses": [{ "address": "<your-origin-hostname>" }],
11 "connection_options": {
12 "transport_policy": "force_https",
13 "host": "<your-origin-hostname>"
14 }
15 }
16}

A resposta retorna o connector, com um valor para cada configuração que a requisição omitiu. Este trecho mostra esses valores:

JSON
01{
02 "state": "pending",
03 "data": {
04 "id": <connector-id>,
05 "name": "origin-connector",
06 "last_editor": "user@example.com",
07 …
08 "active": true,
09 …
10 "type": "http",
11 "attributes": {
12 "addresses": [
13 {
14 "active": true,
15 "address": "<your-origin-hostname>",
16 "http_port": 80,
17 "https_port": 443,
18 "modules": null
19 }
20 ],
21 "connection_options": {
22 "dns_resolution": "both",
23 "transport_policy": "force_https",
24 "http_version_policy": "http1_1",
25 "host": "<your-origin-hostname>",
26 "path_prefix": "",
27 "following_redirect": false,
28 "real_ip_header": "X-Real-IP",
29 "real_port_header": "X-Real-PORT"
30 },
31 "modules": {
32 "load_balancer": { "enabled": false, "config": null },
33 "origin_shield": { "enabled": false, "config": null }
34 }
35 },
36 …
37 }
38}

O connector está ativo, e o endereço dele aceita conexões HTTPS na https_port 443. Load Balancer e Origin Shield começam desativados. Anote o id: a regra o passa como <connector-id>.

Para criar o connector pelo Azion Console:

Abra a página Connectors

Acesse Azion Console > Connectors.

Inicie um novo connector
Nomeie o connector

Em General, insira origin-connector como Name.

Selecione o tipo HTTP

Em Connector Type, selecione o tipo HTTP.

Insira o hostname da sua origem como endereço

Em Address Management, insira <your-origin-hostname> em Address, sem protocolo e sem porta.

Envie o mesmo hostname no header Host
Conecte-se à origem somente por HTTPS

Em Transport Protocol Policy, selecione a opção que usa somente HTTPS.

Selecione Create

O connector existe na sua conta, e a regra que você adiciona à aplicação o seleciona. Para todos os campos do formulário do connector, consulte Connectors.

Crie a aplicação

Uma aplicação guarda as regras que decidem o que acontece com cada requisição. Ela precisa apenas de um nome, e todas as outras configurações mantêm o valor padrão. Enquanto uma regra não nomear um connector, a aplicação não tem uma origem para onde enviar as requisições.

Para criar a aplicação pela Azion CLI:

azion create application --name first-application --active true

A saída traz o ID da aplicação:

Created Application with ID <application-id>

A aplicação está ativa e não tem regras. Cache e Functions começam ativados, e Application Accelerator e Image Processor começam desativados. Anote o ID: a regra e o deployment o passam como <application-id>.

Para criar a aplicação pela API, envie uma requisição POST para o endpoint de applications. Substitua [TOKEN VALUE] pelo seu personal token:

Shell
01curl --request POST \
02 --url https://api.azion.com/v4/workspace/applications \
03 --header 'Accept: application/json' \
04 --header 'Authorization: Token [TOKEN VALUE]' \
05 --header 'Content-Type: application/json' \
06 --data '{"name": "first-application", "active": true}'

Na resposta, modules lista os interruptores com que a aplicação começa:

JSON
01{
02 "state": "pending",
03 "data": {
04 "id": <application-id>,
05 "name": "first-application",
06 "last_editor": "user@example.com",
07 …
08 "modules": {
09 "cache": { "enabled": true },
10 "functions": { "enabled": true },
11 "application_accelerator": { "enabled": false },
12 "image_processor": { "enabled": false }
13 },
14 "active": true,
15 "debug": false,
16 "product_version": "3.0",
17 …
18 }
19}

A aplicação está ativa e não tem regras. Em modules, cache e functions começam ativados, enquanto application_accelerator e image_processor começam desativados. Anote o id: a regra e o deployment o passam como <application-id>.

Para criar a aplicação pelo Azion Console:

Abra a página Applications

Acesse Azion Console > Applications.

Inicie uma nova aplicação
Nomeie a aplicação

Em General, insira first-application como Name.

Selecione Create

A aplicação existe, e a aba Rules Engine dela ainda não tem regras.

Envie toda requisição para o connector

Uma regra no Rules Engine para Applications combina critérios com behaviors. Esta regra roda na fase de requisição. O critério dela, ${uri} começando com /, corresponde a toda requisição. O behavior dela, Set Connector, envia cada requisição correspondente para o seu connector. Para mais informações, consulte Set Connector.

O critério usa ${uri}, não ${request_uri}. ${request_uri} precisa de Application Accelerator ativado. Em uma aplicação sem ele, a API recusa a regra com 400 e o erro 25047, Missing Required Modules.

Para criar a regra pela Azion CLI, mantenha a regra em um arquivo: em uma linha de comando, o shell expandiria ${uri}. Salve este corpo como rule.json e substitua <connector-id> pelo ID do seu connector:

JSON
01{
02 "name": "send-to-origin",
03 "active": true,
04 "criteria": [
05 [
06 {
07 "variable": "${uri}",
08 "conditional": "if",
09 "operator": "starts_with",
10 "argument": "/"
11 }
12 ]
13 ],
14 "behaviors": [
15 {
16 "type": "set_connector",
17 "attributes": { "value": <connector-id> }
18 }
19 ]
20}

Cada grupo em criteria abre com uma condição cujo conditional é if. Crie a regra na fase de requisição da sua aplicação. Substitua <application-id> pelo ID da sua aplicação:

azion create rules-engine --application-id <application-id> --phase request --file rule.json

A saída traz o ID da regra:

Created Rules Engine with ID <rule-id>

A regra está ativa na sua aplicação e envia toda requisição para o seu connector.

Para criar a regra pela API, mantenha o corpo da requisição em um arquivo: em uma linha de comando, o shell expandiria ${uri}. Salve este corpo como rule.json e substitua <connector-id> pelo ID do seu connector:

JSON
01{
02 "name": "send-to-origin",
03 "active": true,
04 "criteria": [
05 [
06 {
07 "variable": "${uri}",
08 "conditional": "if",
09 "operator": "starts_with",
10 "argument": "/"
11 }
12 ]
13 ],
14 "behaviors": [
15 {
16 "type": "set_connector",
17 "attributes": { "value": <connector-id> }
18 }
19 ]
20}

Cada grupo em criteria abre com uma condição cujo conditional é if. Envie uma requisição POST para as regras da fase de requisição da sua aplicação. Substitua <application-id> pelo ID da sua aplicação:

Shell
01curl --request POST \
02 --url https://api.azion.com/v4/workspace/applications/<application-id>/request_rules \
03 --header 'Accept: application/json' \
04 --header 'Authorization: Token [TOKEN VALUE]' \
05 --header 'Content-Type: application/json' \
06 --data @rule.json

A resposta traz a regra armazenada. Este trecho mantém o id, o critério, o behavior e o order dela:

JSON
01{
02 "state": "pending",
03 "data": {
04 "id": <rule-id>,
05 "name": "send-to-origin",
06 "active": true,
07 "criteria": [
08 [
09 {
10 "conditional": "if",
11 "variable": "${uri}",
12 "operator": "starts_with",
13 "argument": "/"
14 }
15 ]
16 ],
17 "behaviors": [
18 {
19 "type": "set_connector",
20 "attributes": { "value": <connector-id> }
21 }
22 ],
23 "description": "",
24 "order": 0,
25 …
26 }
27}

order é 0, a posição da primeira regra na aplicação. A regra está ativa e envia toda requisição para o seu connector.

Para criar a regra pelo Azion Console:

Abra a aplicação

Acesse Azion Console > Applications e selecione a aplicação que você criou.

Selecione a aba Rules Engine
Selecione + Rule
Nomeie a regra

Em General, insira send-to-origin como Name.

Selecione a fase de requisição

Em Phase, selecione Request Phase. A fase de uma regra não pode mudar depois que você cria a regra.

Defina o critério

Em Criteria, selecione a variável ${uri} e o operador starts_with. Em seguida, insira / como argumento.

Selecione o behavior Set Connector

Em Behaviors, selecione Set Connector.

Selecione o seu connector

Em Connector, selecione o connector que você criou.

Selecione Save

A regra aparece na aba Rules Engine, sob o título Request.

Entregue a aplicação por um workload

Um workload guarda o que recebe as requisições: o domínio, os protocolos e os certificados. A aplicação não guarda nenhuma dessas configurações. O deployment do workload nomeia a aplicação que ele executa, e o deployment atual é o que atende as requisições. Um workload novo responde em um domínio de workload que a Azion atribui sob map.azionedge.net.

Para criar o workload pela Azion CLI:

azion create workload --name first-workload --active true

A saída traz o ID do workload:

Created Workload with ID <workload-id>

Crie o deployment que nomeia a sua aplicação. Substitua <workload-id> e <application-id>:

Shell
01azion create workload-deployment --workload-id <workload-id> \
02 --name first-deployment --application-id <application-id> \
03 --strategy-type default --active true --current true

A saída traz o ID do deployment:

Created Workload Deployment with ID <deployment-id>

--current true faz deste deployment o que o workload entrega. Ele nomeia a sua aplicação e nenhum firewall.

Para encontrar o domínio de workload, descreva o workload em JSON:

azion describe workload --workload-id <workload-id> --format json

O campo workload_domain guarda o domínio para onde vai a requisição final.

Para criar o workload pela API, envie uma requisição POST para o endpoint de workloads. infrastructure definido como 1 seleciona a infraestrutura de produção, e workload_domain_allow_access definido como true deixa o workload responder no domínio de workload dele:

Shell
01curl --request POST \
02 --url https://api.azion.com/v4/workspace/workloads \
03 --header 'Accept: application/json' \
04 --header 'Authorization: Token [TOKEN VALUE]' \
05 --header 'Content-Type: application/json' \
06 --data {
07 "name": "first-workload",
08 "active": true,
09 "infrastructure": 1,
10 "workload_domain_allow_access": true
11}

A resposta traz as configurações iniciais do workload e o domínio que a Azion atribuiu a ele:

JSON
01{
02 "state": "pending",
03 "data": {
04 "id": <workload-id>,
05 "name": "first-workload",
06 "active": true,
07 …
08 "infrastructure": 1,
09 "tls": {
10 "certificate": null,
11 "ciphers": 7,
12 "minimum_version": "tls_1_3"
13 },
14 "protocols": {
15 "http": {
16 "versions": ["http1", "http2", "http3"],
17 "http_ports": [80],
18 "https_ports": [443],
19 "quic_ports": [443]
20 }
21 },
22 …
23 "domains": [],
24 "workload_domain_allow_access": true,
25 "workload_domain": "<your-workload-domain>",
26 "product_version": "1.0"
27 }
28}

O workload não tem domínios próprios, e workload_domain guarda o domínio que a Azion atribuiu. Anote o id e o workload_domain.

Crie o deployment que nomeia a sua aplicação. Envie uma requisição POST para os deployments do seu workload e substitua <workload-id> e <application-id>:

Shell
01curl --request POST \
02 --url https://api.azion.com/v4/workspace/workloads/<workload-id>/deployments \
03 --header 'Accept: application/json' \
04 --header 'Authorization: Token [TOKEN VALUE]' \
05 --header 'Content-Type: application/json' \
06 --data {
07 "name": "first-deployment",
08 "current": true,
09 "active": true,
10 "strategy": {
11 "type": "default",
12 "attributes": {
13 "application": <application-id>
14 }
15 }
16}

A resposta retorna o deployment novo, com a sua aplicação em strategy.attributes. current definido como true faz dele o deployment que o workload entrega.

Para criar o workload e o deployment dele pelo Azion Console:

Abra a página Workloads

Acesse Azion Console > Workloads.

Inicie um novo workload

A página Create Workload abre.

Nomeie o workload

Insira um nome, como first-workload.

Selecione a sua aplicação

Em Deployment Settings, defina Application como a aplicação que você criou.

Deixe Firewall e Custom Page vazios
Selecione Create Workload

O workload existe, e o deployment dele nomeia a sua aplicação. Para copiar o endereço para onde vai a requisição final, selecione Copy Workload URL.

Envie uma requisição pelo workload

Esta etapa precisa apenas do curl, qualquer que seja a interface que você usou para montar a cadeia. No comando, substitua <your-workload-domain> pelo domínio de workload do workload que você criou.

Um workload novo não responde de imediato. O primeiro deployment dele pode levar vários minutos para chegar ao tráfego, e nenhuma duração é garantida. Até lá, o domínio de workload responde 404 com uma página provisória. Enquanto o deployment se propaga, as respostas à mesma requisição podem alternar entre esse 404 e a resposta da sua origem. Repita a requisição até a resposta vir da sua origem.

Envie uma requisição para o caminho raiz do seu domínio de workload:

curl -i https://<your-workload-domain>/

A resposta é a que a sua origem retorna para /: o status, os headers e o corpo dela. Qualquer outro caminho chega à sua origem da mesma forma, porque a regra corresponde a toda URI que começa com /. A sua aplicação agora envia toda requisição no domínio de workload dela para a sua origem pelo connector.

Próximos passos

Primeiros passos com CacheCrie um cache setting, aplique-o a um caminho com uma regra e leia se uma resposta veio do cache.Primeiros passos com Application AcceleratorAtive Application Accelerator e coloque em cache uma listagem que varia por um argumento de query string.Primeiros passos com Image ProcessorAtive Image Processor, dê a cada transformação a sua própria entrada de cache e requisite a sua primeira imagem derivada.Rules Engine para ApplicationsAs fases, variáveis, operadores e behaviors que uma regra em uma aplicação aceita, entre eles Set Connector.Como Applications funcionaComo uma requisição vai de um workload, pelas regras de uma aplicação, até uma origem.Limites de ApplicationsOs limites de uma aplicação e dos Produtos habilitados nela.