Azure DevOps
Nesta seção, você encontra como integrar o SCM com o provedor Azure DevOps.
A integração do seu
- Criação de Aplicação;
- Criação de Infraestrutura;
- Aplicação de Plugins;
- Execução de Actions.
Pré-Requisitos
1. Criar o repositório para as pipelines
Para integrar o SCM com a StackSpot, o primeiro passo é criar um repositório próprio da sua organização para as pipelines. Desta forma quando definidas, você poderá acioná-las remotamente via API informando os dados de entrada para cada fluxo.
Você pode acessar o Azure DevOps com uma conta Microsoft ou Github, em seguida, crie uma organização e um projeto:
No Azure DevOps, sua organização será equivalente ao seu nome de usuário e seu projeto ao nome do seu repositório. Para acessá-los você deve utilizar a url:
https://dev.azure.com/[ORGANIZATION-NAME]/[PROJECT-NAME]
Onde:
- Organization name: Nome que você definiu para o seu usuário.
- Project Name: Nome que você definiu para o seu repositório.
Exemplo:
https://dev.azure.com/my-username/my-workflow-repo
Você também pode utilizar um Projeto já existente.
2. Gerar o Personal Access Token no Azure DevOps
Dentro da sua organização, o usuário que pode gerar o token está dentro do grupo > ‘Project Collection Administrators’. Confirme se você tem essa permissão na seção ‘Permissions’ da Azure.
- Acesse a sua conta pelo endereço:
https://dev.azure.com/{Your_Organization}e faça o login; - No menu localizado no lado superior direito da página, clique em 'User Settings' e em seguida, clique em 'Personal access tokens';
- Clique no botão 'New Token' e preencha os campos a seguir:
- Name: Informe um nome para o token;
- Organization: Selecione a sua organização;
- Expiration (UTC): Selecione ou defina uma data de expiração para o token;
- Scopes: Selecione entre 'Full access' para acesso total ou 'Custom defined' para escolher as permissões. Se você escolher 'Custom defined', marque os seguintes itens:
- Auditing: Read Audit Log;
- Build: Read & execute;
- Code: Read & Write;
- Packaging: Read & Write;
- Pipeline Resources: Use & manage;
- Project and Team: Read, write & manage.
- Release: Read, write & execute;
- Services Connections: Read, query & manage;
- Para concluir, clique no botão 'Create'. O código do token será exibido temporariamente, copie e salve o código gerado.
Configurar as pipelines automaticamente (Recomendado)
Os passos a seguir são feitos via STK CLI; Para criar as pipelines automaticamente, você precisa cumprir todos os pré-requisitos:
Passo 1. Execute o comando a seguir:
stk run action stackspot-core/setup-scm
Passo 2. O terminal pergunta qual é o seu provedor SCM. Selecione a opção Azure.
Passo 3. Responda as seguintes perguntas:
- Personal Access Token: Informe o Personal Access Token gerado anteriormente no Azure DevOps;
- Project Name: Informe o nome do Project no Azure DevOps;
- Organization name: Informe o nome que você deu para a Organization no Azure DevOps;
- Repository Name: Informe um nome para o repositório que a Action vai criar. Esse será o repositório que vai armazenar os manifestos das sua pipeline.
- Se o repositório informado existir e nele também existir a branch
main, um Pull Request será criado para amain. Se o repositório não existir, a Action cria o repositório e a branchmain. - Ao criar um Project, um repositório é criado automaticamente como mesmo nome. Porém a configuração da pipeline é feita a nível do Projeto (Project), mas o manifesto fica no repositório do Projeto. Dessa forma o preenchimento do nome para o seu repositório (Repository Name) é obrigatório.
Pronto, a Action foi executada.
Confira o seu repositório (Project) no Azure DevOps. No menu principal clique em 'Pipelines', você verá o arquivo "middle-flow" configurado.
Se a configuração foi executada com sucesso, o próximo passo é fazer a integração do Azure DevOps com a sua conta da StackSpot.
Se não foi possível concluir a configuração de forma automática, siga os passos a seguir para realizar toda a configuração manualmente:
Criar o repositório e pipelines manualmente
Os passos a seguir são feitos via STK CLI; Para criar as pipelines automaticamente, você precisa cumprir todos os pré-requisitos:
Passo 1. No terminal STK CLI. Execute os comandos:
mkdir <repo-name>
cd <repo-name>
Exemplo:
mkdir repo-runner-actions
cd repo-runner-actions
Passo 2. Dentro da pasta que você criou, crie o arquivo "middle-flow.yml" com o seguinte conteúdo:
trigger:
- none
name: ${{ parameters.correlation_id }}
parameters:
- name: correlation_id
displayName: Correlation id
type: string
- name: job_display_name
displayName: Job display name
type: string
- name: api_inputs
displayName: Json object with api data
type: string
- name: job_template
displayName: Job template
type: string
- name: resource_repositories_ref
displayName: Resource repository ref
type: string
pool:
name: default
jobs:
- job:
displayName: ${{ parameters.job_display_name }}
steps:
- bash: |
execution_id=$(echo '${{ parameters.api_inputs }}' | jq -cr '.execution_id')
export HTTP_ENABLE_FILE_DEBUG=false
http_code=$(curl -s -o script.sh -w '%{http_code}' https://workflow-api.v1.stackspot.com/workflows/$execution_id --header 'Authorization: Bearer $(secret_stk_login)';)
if [[ "$http_code" -ne "200" ]]; then
echo "------------------------------------------------------------------------------------------"
echo "---------------------------------------- Debug Starting ----------------------------------"
echo "------------------------------------------------------------------------------------------"
echo "HTTP_CODE:" $http_code
echo "RESPONSE_CONTENT:"
cat script.sh
echo "------------------------------------------------------------------------------------------"
echo "---------------------------------------- Debug Ending ------------------------------------"
echo "------------------------------------------------------------------------------------------"
else
chmod +x script.sh
echo "------------------------------------------------------------------------------------------"
echo "---------------------------------------- Starting ----------------------------------------"
echo "------------------------------------------------------------------------------------------"
bash script.sh
echo "------------------------------------------------------------------------------------------"
echo "---------------------------------------- Ending ----------------------------------------"
echo "------------------------------------------------------------------------------------------"
fi
Passo 3. Faça o commit das alterações utilizando os comandos:
git init
git remote add origin https://<org>@dev.azure.com/<org>/<project_name>/_git/<repo_name>
git add .
git commit -m "Setup Runner"
git push
Exemplo:
git init
git remote add origin https://stackspot-azure@dev.azure.com/stackspot-azure/stackspot/_git/stackspot
git add .
git commit -m "Setup Runner"
git push
Cadastrar o arquivo middle-flow na pipeline da Azure DevOps
Após a criação do repositório e das pipelines dos passos anteriores, você deve cadastrar a pipeline: middle-flow. Para isso, acesse a sua organização na Azure DevOps e siga os passos:
Passo 1. Entre no projeto onde se encontra o repositório utilizado no passo anterior.
Passo 2. No menu principal, clique em 'Pipelines', em seguida no canto superior direito clique no botão 'New pipeline';
Passo 3. Selecione a opção 'Azure Repos Git';
Passo 4. Selecione o repositório criado anteriormente para ser o repositório que vai criar a Pipeline;
Passo 5. Clique em 'Existing Azure Pipelines YAML file', em seguida na opção 'Path' selecione o arquivo /middle-flow.yml;
Passo 6. Na tela Review your pipeline YAML, clique no botão 'Variables', em seguida 'New variable';
Passo 7. Você deve cadastrar duas variáveis,a primeira com os seguintes valores:
- Name: Informe exatamente o nome
secret_cli_login; - Value: --- (Não preencha nenhuma valor);
- Marque as duas checkbox:
- 'Keep this value secret';
- 'Let users override this value when running this pipeline'. Clique no botão 'OK' para finalizar.
Passo 8. Na mesma tela, repita o processo. Clique no botão 'Variables', em seguida 'New variable':
- Name: Informe exatamente o nome
secret_git; - Value: --- (Não preencha nenhuma valor);
- Marque as duas checkbox:
- 'Keep this value secret';
- 'Let users override this value when running this pipeline'. Clique no botão 'OK' e em seguida, no botão 'Save' para finalizar.
Passo 8. A pipeline é criada com um nome aleatório, você deve renomear a pipeline para o nome: 'middle-flow'. Para isso acesse novamente no menu principal a opção Pipelines e depois na opção 'all';
Passo 9. Localize a pipeline gerada, e clique no botão 'more options' e depois em 'Rename/move pipeline';
Passo 10. No campo 'Name' digite 'middle-flow' em seguida, clique no botão 'Save'.
Agora, você precisa ter a URL do projeto para utilizar no processo de integração a seguir.
Integrar o Azure DevOps com a StackSpot
Os passos a seguir são feitos no Portal da StackSpot.
Configurar via Azure DevOps PAT (Personal Access Token)
Passo 1. Acesse diretamente link do Portal da Conta; ou após fazer login no Portal StackSpot, clique no seu avatar de perfil;
Passo 2. Selecione a opção 'Organização' no menu exibido;
Passo 3. No menu principal do Portal da Conta, selecione o produto StackSpot EDP e clique em ’SCM’. Em seguida, clique no botão Configurar Integração SCM’;
Passo 4. No campo Selecionar provedor, selecione Azure DevOps;
Passo 5. Em Método de autenticação, selecione a opção PAT (Personal Access Token) e preencha os seguintes campos:
- Usuário: O nome do seu usuário no Azure DevOps;
- Token: Utilize o seu Personal Access Token do Azure DevOps que você gerou anteriormente.
Passo 6. Em Configuração de Workflow, escolha como a organização deseja gerenciar o acesso ao SCM, para isso, habilite ou desabilite a opção 'A organização vai gerenciar o acesso ao SCM via User PAT?':
- Habilitado: O usuário irá gerenciar o acesso ao Azure DevOps via PAT (Personal Access Token).
- Desabilitado: A empresa irá gerenciar o acesso ao Azure DevOps.
Ao habilitar este botão, os membros da sua conta terão que configurar o Acesso de SCM individual deles.
Passo 7. No campo URL do Workflow, insira a URL do repositório criado com as pipelines para a StackSpot identificar onde o seu workflow está configurado. Por exemplo: https://dev.azure.com/myazure-user/scm-azure-pipes.
Passo 8. Você será redirecionado para a tela de Review. Confira seus dados e clique em 'Integrar com StackSpot'.
Pronto, sua configuração está completa.
Esta página foi útil?