Introdução

Crie um fluxo de trabalho para buscar uma taxa de câmbio em tempo real e enviar um alerta se ela estiver abaixo de um determinado limite.

Visão geral

Neste tutorial, criaremos o fluxo de trabalho de Observação de preços : um Maestro Flow que busca uma taxa de câmbio ao vivo de uma API externa, a compara com um limite que definimos e retorna um alerta ou um resultado sem ação com base no limite . Isso mostra como um fluxo de trabalho pode ter lógica de ramificação com base nos valores que recupera. O fluxo tem seis nós, então o foco permanece em como o fluxo conecta dados entre os nós, em vez de em um fluxo de trabalho mais complexo com várias ramificações de lógica.

Tempo estimado: 30 minutos.

O que é o Maestro

O Maestro é uma plataforma de orquestração nativa da nuvem que unifica automação, agentes de IA e interações humanas em processos de negócios de ponta a ponta simplificados. É um mecanismo com três superfície de modelagem:

• Maestro Flow (.flow) para orquestração de autoria do desenvolvedor.
• Maestro BPMN (.bpmn) para diagramas de Modelo de Processos de Negócios e Notation que as partes interessadas dos negócios revisam.
• Maestro Case Management (caseplan.json) para trabalho humano com muitas exceções.

O Flow é um modelador diferente construído no mesmo runtime do Maestro BPMN, projetado para desenvolvedores que preferem uma experiência visual baseada em nós à notação BPMN. Se você tiver criado fluxos de trabalho de Automação de Processos Robóticos (RPA) ou lido um diagrama BPMN antes, os conceitos serão transferidos diretamente; o que muda é a ergonomia. Para obter orientação sobre como escolher uma superfície, consulte Escolhendo um modelador Maestro.

O que você está criando

Vamos construir o restante do Fluxo de Observação de Preços, que recebe três entradas em seu gatilho manual e retorna um objeto com o resultado baseado em nossa lógica. Cada nó no fluxo tem um único trabalho, e o fluxo os conecta para criar o fluxo de trabalho completo.

Abaixo está um diagrama de texto dos diferentes nós, como eles estão conectados e mostra detalhes sobre a finalidade de cada um:

     start              fetchRate1           reshapeRate1        belowThreshold1
┌──────────────┐      ┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│ Manual       │─────▶│ HTTP Request │────▶│ Script       │────▶│ Decision     │
│ trigger      │      │              │     │              │     │              │
└──────────────┘      └──────────────┘     └──────────────┘     └──────┬───────┘
 baseCurrency          GET /v2/rates        reads .body          rate below
 quoteCurrency         ?base&quotes         returns pair,        threshold?
 alertThreshold                             rate, asOf,                │
                                            belowThreshold             │
                                                                ┌──────┴──────┐
                                                           true │             │ false
                                                                ▼             ▼
                                                           endAlert1     endNoAction1
                                                          ┌──────────┐  ┌──────────┐
                                                          │ End      │  │ End      │
                                                          └──────────┘  └──────────┘
                                                           "alert"       "no action"

Dica:

Usaremos os valores de ID mostrados acima, atualizando-os para legibilidade a partir dos gerados - as instruções mostrarão a você como atualizar cada um deles.

A lista a seguir é de todos os componentes que formarão o fluxo:

Component	Detalhes
Entrada: baseCurrency	string, padrão USD; a moeda a partir da qual serão precificados
Entrada: quoteCurrency	string, padrão EUR; a moeda a ser precificada
Entrada: alertThreshold	number, padrão 0.9; alertar quando a taxa ficar abaixo desse valor
Saída: watchResult	object com pair, rate, asOf e belowThreshold
Nó (gatilho manual): start	Inicia a execução sob demanda e carrega as três entradas para o fluxo
Nó (solicitação HTTP): fetchRate1	Envia uma solicitação GET para a API de taxa de câmbio de Franco habilitação
Nó (script): reshapeRate1	Lê o corpo da resposta e retorna pair, rate, asOf e belowThreshold
Nó (decisão): belowThreshold1	Avalia belowThreshold e segue o caminho verdadeiro ou falso
Nó (Final): endAlert1	Retorna watchResult como um objeto com os valores pair, rate, asOf e belowThreshold do nó reshapeRate1
Nó (Final): endNoAction1	Retorna watchResult como um objeto com os valores pair, rate, asOf e belowThreshold do nó reshapeRate1

API do Moeda Exchange

Para obter valores de taxa de câmbio reais, usaremos o FTP, uma API de dados de moeda gratuita e de código aberto que rastreia as taxas de câmbio diárias de fontes institucionais. Ele não precisa de chave de API, conta ou cabeçalho de autenticação, e é por isso que é adequado para criar seu primeiro Fluxo.

Um exemplo de resposta para a taxa de USD para EUR da API contém uma matriz JSON com uma entrada por moeda cotada:

[
  {
    "date": "2026-09-01",
    "base": "USD",
    "quote": "EUR",
    "rate": 0.86111
  }
]

Observação:

O formato da array é importante para o nó do Script que você cria posteriormente: a taxa não está em um caminho fixo, então o script pesquisa a entrada que quote corresponde à sua entrada quoteCurrency em vez de ler uma chave conhecida.

Pré-requisitos

• Node.js e npm no seu PATH - a interface de linha de comando da UiPath (CLI) (uip) é instalada com npm. Verifique com node --version e npm --version e instale a partir do nodejs.org se algum estiver ausente.
• Uma conta da UiPath - inscreva-se ou faça login no UiPath Automation Cloud antes de começar.
• Um tenant com o Maestro Flow habilitado - as execuções de depuração e a implantação rotearão por meio do tenant selecionado.
• Acesso de rede ao seu ambiente UiPath - O login da CLI usa um fluxo de navegador OAuth com um retorno de chamada na localhost porta 8104.
• Código VS 1.110.0 ou superior com a extensão UiPath Maestro - necessário para criar na tela e útil em qualquer caminho para observar o fluxo tomar forma. Verifique sua versão em Código > Sobre o Visual Studio Code ou code --version.

Nenhuma experiência anterior da UiPath é necessária, e você não precisa abrir o Studio Web em qualquer momento neste tutorial.

Dica:

Trabalhando em um espaço de trabalho remoto? No Windows Subsystem for Linux (WSL), Secure Shell (SSH), Codespaces e espaços de trabalho de contêiner dev, a extensão é executada no host remoto, portanto, o UiPath CLI deve ser instalado lá, em vez de em sua máquina local.

Se você não instalou os pré-requisitos antes, siga as etapas para configurar seu ambiente para tutoriais da UiPath. Use uip --version e uip login status para verificar se a CLI está instalada e se você a autentique.

Etapa 1 - Estruturar o fluxo de Observação de Preços

Uma solução é a unidade implantável que contém um ou mais projetos que usaremos para empacotar e implantar nosso fluxo. Vamos começar criando a solução primeiro e, depois, o projeto de Fluxo dentro dela:

1. Criar a solução - cria um diretório com o nome que você especifica por meio uip solution init <solution name> de.

   uip solution init tutorial-maestro-flow-price-watch
   

2. Altere para o diretório de solução recém-criado.

   cd tutorial-maestro-flow-price-watch
   

3. Crie o projeto de fluxo dentro da solução.

   uip maestro flow init PriceWatch
   

   Observação:

   O comando flow init cria o diretório PriceWatch/ contendo PriceWatch.flow (o único arquivo que você edita), project.uiproj e operate.json. Quando flow init é executado de dentro de um diretório de soluções, ele também registra o projeto na solução pai e relata "Status": "Registered". Ele também cria uma pasta resources/ na raiz da solução, que contém o estado gerado que o empacotamento regenera cada vez que implantamos, mas você não precisará editar esses arquivos para este tutorial.

4. Confirme se o fluxo foi estruturado com um único nó de gatilho:

   uip maestro flow node list PriceWatch/PriceWatch.flow --output table
   

   Você deve ver apenas uma única linha para trigger na saída - suas coordenadas X e Y podem ser diferentes, pois elas mudam à medida que você move nós na tela visual:

   Id              | Type                | Label           | Position                         
   ----------------|---------------------|-----------------|----------------------------------
   start           | core.trigger.manual | Manual trigger  | {"X":-192,"Y":0}
   

5. Abra o arquivo PriceWatch/PriceWatch.flow no VS Code. Com a extensão do UiPath Maestro instalada, o arquivo é aberto na tela visual em vez de como texto bruto, permitindo que você veja a representação visual do seu fluxo de trabalho.

   

---

Próxima etapa

Agora estamos prontos para criar nosso Fluxo.