Vamos a instalação e configurações. Os primeiros passos são os mesmos da última versão, basta iniciar a instalação e seguir o passo-a-passo.

Após instalado, vamos as primeiras configurações. Nessa primeira tela já podemos ver algumas diferenças no produto, como a configuração da nova funcionalidade de Search. Iremos fazer essa configuração durante o processo de upgrade, mas não é obrigatória, por isso temos ela aqui, para quando houver necessidade de instalar em um TFS já configurado. Vamos selecionar “Configure Team Foundation Server” e clicar em Start Wizard.

A primeira decisão é se será uma nova instalação de TFS ou um Upgrade. Nesse caso farei o upgrade das bases existentes.

Escreva o nome da instancia dos bancos de dados existentes do TFS e clique em “List Available Databases” para verificar se o banco de dados existe e está em uma versão suportada para upgrade. Além disso, garanta que os backups foram feitos, clique no ckeckbox “By checking this box, I confirm that I have a current backup” e clique em “Next”.

Essa tela é uma outra novidade muito útil. Aqui temos dois cenários diferentes:

1. Production Upgrade Selecionando esse primeiro cenário, o upgrade acontece como era nas versões anteriores, sem muito segredo.
2. Pre-Production Upgrade Testing Selecionando o segundo cenário, outros passos serão executados durante o procedimento de upgrade. Para executar o upgrade em um ambiente de pré-produção ou homologação do TFS, que normalmente utiliza bancos de dados restaurados do ambiente de produção, devemos tomar alguns cuidados para não interferir no funcionamento do ambiente de produção.

Caso seja uma atualização do ambiente de homologação, a tela abaixo será apresentada explicando os detalhes dos procedimentos adicionais que serão executados. Além disso é recomendado que nesse servidor de pré-produção o arquivo hosts da máquina seja alterado para que de nenhuma forma esse servidor encontre os servidores de produção. Também é recomendado a utilização de usuários específicos para esse ambiente, e não utilizar os mesmos usuários do TFS de produção.

Em meu caso, estou fazendo o procedimento já em ambiente de produção, sendo assim, escolhi o primeiro cenário. Após selecionar o cenário que deseja executar, clique em “Next”, na próxima tela escolha o usuário e senha que será utilizada para a conta de serviço do TFS.

Escolha se o endereço do TFS irá utilizar HTTPs e HTTP, somente HTTP, ou se ficará no endereço default já conhecido das antigas instalações. Ex.: https://TfsAppTier:8080/tfs. Vou utilizar a configuração default como já estava utilizando, e também habilitar a configuração de SSH. Se escolher utilizar HTTPs, configure com um certificado válido. Para mais detalhes: https://www.visualstudio.com/en-us/docs/setup-admin/websitesettings

Como dito no início do post, é possível instalar e configurar a funcionalidade de Search durante o processo de Upgrade. Sendo assim, selecione o checkbox “install and configure search”. Como é a primeira vez que estou instalando o serviço, vou selecionar a opção de nova instalação, porém se já tiver configurado, pode utilizar a mesma. Escolha a pasta onde serão indexados os arquivos de busca. É recomendado que esses arquivos sejam armazenados em um SSD para garantir a performance.

Nota: Para que o Search funcione, alguns pré-requisitos são necessários. Vamos falar deles mais a baixo, no momento de validação.

Irei utilizar o mesmo usuário e senha que utilizo no serviço do TFS, pois estou fazendo o upgrade em um laboratório de testes, mas recomendo que seja criada uma nova conta para esse serviço, assim como é feito com os outros serviços do TFS.

Como as outras configurações daqui para a frente continuam as mesmas, irei passar rapidamente por elas. Aqui vamos configurar novamente o Reporting Services e Analysis Services. Como não estou utilizando o Sharepoint, irei pular essa configuração.

Como nesse caso o Report Server já existia e estava configurado, preencha a instancia de Reporting Services e clique em “Populate URLs” para o autopreenchimento.

Preencha a instancia do SQL Server para identificar o Tfs_Warehouse.

Preencha a instancia onde está configurado o Analysis services.

Preencha o usuário e senha do Reports.

Após todas as configurações, vamos verificar se todas estão corretas. Clique em “Verify”.

Como dito anteriormente, com a nova funcionalidade do Search, alguns pré-requisitos devem ser atendidos. Nesse caso precisamos instalar o Oracle Server JRE 7 Update 55 (ou maior), ou o JRE 8 Update 20 (ou maior). Podemos instalar primeiro e validar novamente a instalação, ou aceitar os termos e ele será instalado e configurado pela própria instalação do TFS. Veja que nesse ponto ele vai criar a variável JAVA_HOME. Vou aceitar os termos e clicar em “Configure”.

Após a configuração, todos os requisitos serão validados e finalizados.

Clicando em “Next” novamente teremos alguns detalhes, como por exemplo, a configuração do JAVA_HOME, exceção do firewall, etc.

Por fim, clique em “close” e abra a URL do TFS e o TFS Console para validar o upgrade.

Upgrade realizado com sucesso e com novas ótimas features!!!

Por hoje é só!! Até a próxima!

O primeiro passo é garantir que o Android Studio e o Visual Studio Emulator for Android estão instalados e funcionando. Com o Emulador instalado, assim que você abrir o Android Studio para tentar executar a aplicação, se o Visual Studio Emulator estiver aberto, o Android Studio vai encontrar ele como um possível dispositivo conectado para execução da aplicação. Ou seja, não precisaríamos fazer os passos a seguir para que uma aplicação criada no Android Studio executasse no novo emulador Visual Studio Emulator for Android. Porém esses passos a seguir facilitam a utilização do emulador no dia a dia, pois adiciona atalhos no Android Studio, evitando ter que iniciar o emulador fora da IDE. Vamos para as configurações dos atalhos:

Abra o Android Studio –> Run –> Edit configurations…

Expandir o menu Defaults –> Clicar em Android Application. Em Deployment Target Options selecionar “Show Device Chooser Dialog” e clicar no checkbox “Use same device for future launches” e clique em OK. Com isso toda execução da aplicação irá abrir a janela perguntando qual o Device que deve ser utilizado e lembrará a opção definida.

Agora clique em File –> Settings –> Tools –> External Tools –> Add.

Aqui vamos adicionar o Emulator Manager ou os emuladores que serão utilizados.

Preencha o campo Name para identificar a ferramenta e uma descrição. Nos outros campos preencha:

Program: C:\Program Files (x86)\Microsoft Emulator Manager\1.0\emulatormgr.exe

Parameters: /sku:Android

Clique em OK.

Working directory: $ProjectFileDir$ (vou utilizar uma variavel que é substituída pela pasta do projeto)

Nesse caso cadastrei primeiro a ferramenta para abrir o gerenciador de emuladores, por isso selecionei o emulatormgr.exe que está na pasta de instalação do emulador.

Agora vamos cadastrar um atalho para abrir direto um dos emuladores instalados. Abra o prompt de comando na pasta em que o emulador foi instalado (nesse exemplo: C:\Program Files (x86)\Microsoft Emulator Manager\1.0\) e digite: “emulatorcmd.exe /sku:Android list /type:device”. Esse comando irá listar todos os emuladores instalados, suas versões e identificadores.

Com isso em mãos, adicione uma nova External tool clicando em Add. Novamente preencha os campos, mas agora com outras informações:

Name: 5.1" Marshmallow (6.0.0) XXHDPI Phone (Escrevi o mesmo nome de um dos emuladores listados acima que estou adicionando)

Program: C:\Program Files (x86)\Microsoft Emulator Manager\1.0\emulatorcmd.exe (note que agora não estamos abrindo o gerenciador, e sim vamos selecionar um dos emuladores)

Parameters: /sku:Android launch /id:8AB3CF93-0E9D-4EF8-B132-66D6D7AB4820 (O mesmo ID referente ao emulador da lista)

Clique em OK e OK novamente para finalizar após adicionar os emuladores que pretende utilizar.

Clique com o botão direito na barra de ferramentas do Android Studio –> Customize Menos and Toolbars…

Vamos expandir a área Main Toolbar. Escolha o local onde vai adicionar os atalhos do Emulador criados anteriormente. Em meu caso criei após o último ícone, help. Se quiser fazer o mesmo, clique no link Help Topics –> clique no botão Add After…

Com isso irá abrir uma nova janela para escolher os atalhos. Clique em All Actions –> External Tools –> External Tools –> Selecione os emuladores cadastrados e clique em OK. Você pode selecionar um novo ícone para esses atalhos. Para finalizar clique em OK novamente.

Os ícones foram criados e estão na barra de ferramentas da IDE. Agora clique no ícone de algum dos emuladores criados para abrir o emulador.

Por fim com a aplicação aberta no Android Studio e com o emulador funcionando, clique em play para executar a aplicação e uma janela será aberta perguntando onde deve ser executada.

Clique no emulador do Visual Studio “VS Emulador” e clique em OK. Sua aplicação será executada no novo emulador.

That’s it.

Referência: https://blogs.msdn.microsoft.com/visualstudioalm/2015/07/20/using-the-visual-studio-emulator-for-android-from-android-studio-or-eclipse-with-adt

Como estou fazendo essa instalação para laboratório de testes, utilizei o Azure DevTest Labs para criar minha VM. Ele facilita muito por já ter os templates de VMs que normalmente preciso, além de algumas outras funcionalidades de que gosto muito, como auto-start e auto-shutdown. O Sonar suporta diversas versões de banco de dados, porém utilizei o SQL Server 2014 SP1 Express rodando em um Windows Server 2012 R2.

No Azure DevTest Labs clique em + Virtual machine e selecione o template “SQL Server 2014 SP1 Express on Windows Server 2012 R2”:

Após isso basta preencher as informações (Nome, Usuário, Senha, etc.), escolher o tamanho da máquina a ser utilizada, rede, subnet e clicar em Create:

Após alguns instantes a máquina será criada e disponibilizada para utilização. É possível se conectar na máquina virtual via RDP ou clicando em Connect no portal do Azure. Caso você esteja utilizando uma máquina virtual que não esteja no DevTest Labs, será necessário liberar os endpoints das portas de SQL (Default: 1433) e do Sonar (Default: 9000) para acesso externo.

Um dos pré-requisitos para o SonarQube é a instalação do Java. Faça a instalação seguindo os passos recomendados pelo produto e não esqueça de criar a variável de ambiente JAVA_HOME e atualizar o Path do Windows com o endereço de instalação.

Os próximos passos são as configurações do SQL Server. Para iniciar basta abrir o SQL Management Studio e clicar em connect. Após isso clique com o botão direito na instância de SQL e em propriedades.

Clique em Security –> SQL Server and Windows Authentication mode –> OK.

Além disso o Sonar precisa de um usuário com acesso ao SQL Server. Como é um cenário para laboratório, criei um novo usuário no SQL Server com permissão de sysadmin. Para isso clique em Server Roles –> sysadmin.

Agora é possível criar nosso banco de dados do Sonar. Clique em botão direito em Databases –> New database. De um nome para o banco de dados e clique em options para trocar a collation. Esse é um dos passos mais importantes, pois é o requisito principal de banco de dados para o Sonar. Selecione a collation SQL_Latin1_General_CP1_CS_AS e clique em OK.

A última configuração necessária para o SQL Server agora é habilitar o protocolo TCP. Abra o Sql Server Configuration Manager –> SQL Server Network Configuration –> Protocols for MSSQLSERVER  -> Botão direito em TCP/IP –> Enable. Reinicie o serviço de SQL Server para que as alterações de segurança tenham efeito.

Agora vamos para a instalação do Sonar. Faça o download do Sonar em https://www.sonarqube.org/downloads. Clique com o botão direito no arquivo –> Properties –> Unblock –> OK.

Extraia o arquivo para a pasta que gostaria que ficasse instalado. Em meu caso vou deixar em C:\sonarqube-5.6. Agora vamos configurar o Sonar para indicar o banco de dados que ele irá utilizar, assim como o usuário, senha e endereço de serviço. Entre na pasta onde o Sonar foi extraido –> conf –> abra o arquivo sonar.properties.

Com o arquivo aberto procure o bloco “# User credentials.”, remova o comentário (#) das linhas sonar.jdbc.username e sonar.jdbc.password e preencha as informações do usuário adicionado no SQL Server e a senha:

Altere também a conexão com o banco de dados. Remova o comentário (#) e atualize com as informações do banco de dados criado:

sonar.jdbc.url=jdbc:sqlserver://localhost;databaseName=SonarQube;SelectMethod=Cursor

Feche o arquivo e salve. Com esses passos, o Sonar já está configurado e pronto para funcionar. É possivel executa-lo por linha de comando, porém vou demonstrar como configura-lo como serviço.

Pelo CMD/Powershell vá até a pasta de instalação do Sonar –> bin –> windows-x86-64.

Execute o comando InstallNTService e aperte enter para instalar o Sonar como serviço. Ainda no CMD digite o comando “sc config SonarQube depend= MSSQLSERVER” (sem os aspas) para que o novo serviço do Sonar seja dependente do serviço de SQL Server (Somente se o Sonar estiver sendo instalado na mesma máquina do SQL Server). Assim caso o SQL Server não esteja sendo executado, o Sonar também não será.

Com isso o Sonar foi instalado como um Windows Service. Entre agora nos serviços do windows (Win+R = services.msc) e encontre o serviço do Sonar para alterar o usuário e senha de execução. Clique com o botão direito no serviço –> Log on –> This account –> Preencha o usuário e senha que o Sonar irá utilizar –> clique OK. Por fim, clique com o botão direito e inicie o serviço clicando em Start.

Se todas as configurações estiverem de acordo, abra o browser por dentro da VM e digite o endereço do Sonar: https://localhost:9000 e aperte enter.

Se quiser que o endereço fique disponível para acesso externo, abra novamente o prompt de comando e digite “netsh advfirewall firewall add rule name="SonarQube" dir=in action=allow protocol=TCP localport=9000” para liberar a porta 9000 no firewall e garantir o acesso. Isso pode ser feito também com a porta do SQL Server.

O Sonar está pronto para ser utilizado!

That’s it.

Para conectar na VM estou utilizando o Bash on Ubuntu on Windows do Windows 10.

Entrei na VM utilizando SSH e executei alguns comandos para instalar os pré-requisitos e a SDK:

Atualização de pacotes:

sudo apt-get update

Instalação do Java:

sudo apt-get install default-jdk

Instalação do OpenJDK:

sudo apt-get install openjdk-8-jre

Download do Android SDK:

wget https://dl.google.com/android/android-sdk_r24.4.1-linux.tgz

tar -xvf android-sdk_r24.4.1-linux.tgz
cd android-sdk-linux/tools

Instalação dos pacotes SDK:

./android update sdk --no-ui

Configurando JAVA_HOME e Path:

sudo update-alternatives --config java

#Abrir /etc/environment
sudo nano /etc/environment

#Adicionar complemento ao Path
PATH=${PATH}:$HOME/sdk/android-sdk-linux/platform-tools:$HOME/sdk/android-sdk-linux/tools:$HOME/sdk/android-sdk-linux/build-tools/24.0.1/

#Adicionar o caminho no final do arquivo
JAVA_HOME="/usr/bin/java

#Atualizar o arquivo
source /etc/environment

Build com sucesso!!

That’s it.

Para gravar o cenário de testes vou utilizar o Selenium IDE plug-in para Firefox. Porém poderia utilizar o próprio Coded UI Test Builder para gravar e fazer com que executasse em outro browser.

Após instalar o Selenium components for Coded UI Cross Browser Testing, vou criar um novo projeto do tipo Coded UI Test Project, pois minha intenção é utilizar o MSTest, porque ele já carrega algumas referências necessárias. Se a intenção for utilizar o xUnit ou NUnit, você poderia utilizar uma Class Library, inclusive utilizar NUnit pode ser mais simples para quem quer gravar os testes com Selenium, pois já pode exportar para direto da Selenium IDE para C# NUnit e executar no Visual Studio de forma simples.

Assim que o projeto é criado a janela para gravar os cenários utilizando Test Builder será aberta, vou ignorar e cancelar.

O próximo passo agora é adicionar os assemblies e drivers do Selenium no projeto de Coded UI criado utilizando o gerenciador do Nuget e adicionar suas referências a classe. Eu instalei somente os drivers do Chrome e do IE, porque o driver de Firefox já faz parte do core framework e não precisa ser instalado a parte.

Referências:

using OpenQA.Selenium.Firefox;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.IE;
using OpenQA.Selenium;

Como estou utilizando a classe default criada junto com o projeto de Coded UI, ela tem um trecho de código comentado “Additional test attributes” que vou utilizar para preparar o driver que utilizarei em meus testes. O método TestInitialize será executado antes de cada método de testes. O interessante de criar o driver aqui é que ele fica centralizado em um único lugar para todos os testes dessa classe. Como vou utilizar o mesmo browser e URL para esses testes, vou colocar aqui também a chamada ao site que será testado e realizar a navegação.

#region Additional test attributes

        // You can use the following additional attributes as you write your tests:

        ////Use TestInitialize to run code before running each test 
        [TestInitialize()]
        public void MyTestInitialize()
        {
            // To generate code for this test, select "Generate Code for Coded UI Test" from the shortcut menu and select one of the menu items.
            driver = new ChromeDriver();
            baseURL = https://blogs.msdn.microsoft.com/;
            driver.Navigate().GoToUrl(baseURL);
            driver.Manage().Window.Maximize();
            driver.Manage().Timeouts().ImplicitlyWait(TimeSpan.FromSeconds(30));
        }

        ////Use TestCleanup to run code after each test has run
        [TestCleanup()]
        public void MyTestCleanup()
        {
            // To generate code for this test, select "Generate Code for Coded UI Test" from the shortcut menu and select one of the menu items.
            try
            {
                driver.Quit();
            }
            catch (Exception)
            {
                // Ignore errors if unable to close the browser
            }
        }

#endregion

Result Message:    Initialization method TestesAutomatizados.Selenium.TestandoComSelenium.MyTestInitialize threw exception. OpenQA.Selenium.DriverServiceNotFoundException: OpenQA.Selenium.DriverServiceNotFoundException: The chromedriver.exe file does not exist in the current directory or in a directory on the PATH environment variable. The driver can be downloaded at http://chromedriver.storage.googleapis.com/index.html..

Isso aconteceu porque os testes não estão sendo executados onde está o projeto. Para resolver, precisei “falar” para o Test Framework copiar o chromedriver.exe que foi adicionado ao projeto quando instalei a referência do Nuget, para a pasta onde os testes vão ser executados. Utilizei o atributo DeploymentItem na Test Class.

namespace TestesAutomatizados.Selenium
{
    /// <summary>
    /// Summary description for CodedUITest1
    /// </summary>
    [CodedUITest]
    [DeploymentItem("chromedriver.exe")]
    public class TestandoComSelenium
…

Agora é possível executar os testes! Nesse caso, por enquanto como não gravamos nenhum cenário, somente o browser será aberto no endereço padrão escrito no método MyTestInitialize. Sendo assim, vamos gravar nosso primeiro cenário!

Vou utilizar a Selenium IDE para gravar o cenário de Testes. Após a instalação, ao abrirmos a IDE teremos a seguinte tela:

O objetivo do meu cenário de teste é abrir meu blog, entrar em um de meus posts e fazer um comentário. Como já programamos a execução do browser no endereço correto, vamos gravar desse ponto para frente. Após abrir o browser e entrar na aplicação, vou abrir e iniciar a gravação no Selenium IDE e executar as ações como se estivesse navegando como um usuário comum.

1. Abrir website
2. Clicar em um post
3. Preencher informações pessoais (nome, e-mail, website)
4. Escrever comentário
5. Publicar comentário

Agora vamos exportar esse caso de teste. File –> Export Test Case As… –> C# / NUnit / WebDriver:

Não estou utilizando NUnit, porém vou utilizar parte da classe gerada em nosso teste configurado anteriormente. Ficando somente com as chamadas dos elementos da classe exportada pelo Selenium IDE e adicionando em meu método no Coded UI, ele ficou assim:

        [TestMethod]
        [TestCategory("UI")]
        public void abrir_post_e_fazer_um_comentario()
        {
            driver.Navigate().GoToUrl(baseURL + "/luizmacedo/");
            driver.FindElement(By.LinkText("Livro: Desenvolvimento efetivo na plataforma Microsoft")).Click();
            driver.FindElement(By.Id("author")).Clear();
            driver.FindElement(By.Id("author")).SendKeys("Luiz");
            driver.FindElement(By.Id("email")).Clear();
            driver.FindElement(By.Id("email")).SendKeys("luizmacedo@outlook.com");
            driver.FindElement(By.Id("url")).Clear();
            driver.FindElement(By.Id("url")).SendKeys("https://blogs.msdn.microsoft.com/luizmacedo");
            driver.FindElement(By.Id("comment")).Clear();
            driver.FindElement(By.Id("comment")).SendKeys("Meu primeiro comentário utilizando testes automatizados!!!");
            driver.FindElement(By.Id("submit")).Click();
        }

A criação do cenário de testes foi finalizada e a integração com Selenium está funcionando. Agora é só executar o teste e esperar o resultado. Nesse caso estou utilizando o Google Chrome, mas poderia estar executando pelo Firefox, IE ou com outros browsers que tenham o WebDriver do Selenium disponível.

O que é o Docker? https://www.docker.com/what-docker

Existem diferentes formas de criar um Docker Host, vou demonstrar uma delas nesse post.

O primeiro passo será criar uma nova máquina virtual com Linux no Azure que suporte a extensão Docker VM. Nesse caso irei utilizar uma imagem da galeria do Azure para facilitar o trabalho, Ubuntu Server 15.10.

Em determinado passo no processo de configuração para criar a nova máquina virtual, será possível incluir extensões. Vamos incluir a Docker Extension.

Para que seja possível criar a VM com a extensão do Docker, no momento de instalação da extensão é necessário realizar o upload de três certificados para o Docker Engine e configurar a porta de conexão.

Para a criação dos certificados serão seguidas as seguintes recomendações: https://docs.docker.com/engine/security/https.

Utilizei uma outra máquina Linux que tenho para a criação dos certificados. Também é possível instalar a VM sem essa extensão e realizar o processo de instalação manual após a criação da VM, mas preferi facilitar o processo e ter a VM com ela instalada desde o início.

Após a criação, devemos selecionar os certificados criados.

Por fim, falta validar as configurações e finalizar a criação da VM.

Quando a VM estiver criada, vamos configurar um DNS name label para encontrar a máquina de forma mais fácil e eficiente. Basta clicar nas configurações de Public IP –> Settings –> Configuration –> DNS name label.

Na criação dos certificados esse DNS pode ser utilizado na configuração de CN. Ex.: openssl req -subj "/CN=host.southcentralus.cloudapp.azure.com" -new -key server-key.pem -out server.csr

O próximo passo é criar um novo endpoint para que seja possível encontrar o Docker Host criado no Azure. Clique no Network Security Group da VM criada –> Settings –> Inbound security rules –> add.

Criei o endpoint TCP para a porta 2376, default do Docker.

Por fim, basta testar se a conexão com o Docker Host está funcionando, utilizando o comando a seguir pela máquina cliente:

Ex.: $ docker --tls --tlscacert=ca.pem --tlscert=cert.pem --tlskey=key.pem -H tcp://host.southcentralus.cloudapp.azure.com:2376 info

Para validar a versão:

Ex.: docker --tlsverify --tlscacert=ca.pem --tlscert=cert.pem --tlskey=key.pem -H=host.southcentralus.cloudapp.azure.com:2376 version

São apresentadas as informações do Docker Host pronto para ser utilizado.

1. Entre nas configurações de contas de usuário do Windows e desative a opção “Users must enter a user name and password to use this computer”
2. Preencha o usuário e senha que será utilizado para efetuar login automaticamente clique em ok.
3. Agora vamos criar um atalho para iniciar automaticamente nosso build agent no Startup do Windows:
   • Windows + R
   • Digite Shell: Startup e aperte Enter
   • Crie um novo atalho (botão direito na pasta –> novo –> atalho) com o caminho onde estão seus arquivos do Agent
     • Ex.: C:\Windows\System32\cmd.exe /c c:\agent1\agent\vsoagent.exe
4. Pronto. Ao abrir esse atalho o Agent será executado em modo interativo. Mantenha-o executando e verifique seu status no portal do VSTS/TFS.

Obs.: Gostaria de lembrar que essas configurações vão permitir que o Windows faça login automaticamente com esse usuário, sendo assim essas configurações devem ser utilizadas com cuidado.

1. Abra o endereço de seu VSTS/TFS. Ex.: https://url.visualstudio.com/DefaultCollection/TeamProject
2. Clique na engrenagem no canto superior direito para abrir a área de administração
   
   
   
3. Selecione o Control Panel
4. Clique na aba Agent pools
5. Clique no link Download agent
   
   
   
6. Salve o arquivo em uma pasta de sua preferencia
7. Clique com o botão direito no arquivo agent.zip
8. Selecione as propriedades do arquivo
9. Verifique se o arquivo está desbloqueado
   
   
   
10. Extraia o arquivo para a pasta onde ele será instalado e configurado
11. Eu continuo instalando um agent por Core, por isso vou nomear a pasta como Agent1
12. Execute o arquivo ConfigureAgent.cmd com privilégios elevados
    
    
    
13. Preencha as informações requeridas ou se for o caso aperte “enter” para as opções default apresentadas:
    • Nome do Agent
    • URL do VSTS/TFS. Ex.: https://url.visualstudio.com/DefaultCollection
    • Preencha o Agent Pool do Agent
    • Preencha a work folder do Agent
    • Preencha Y/N para instalar o Agent como serviço ou não.
    • Caso escolha executar como serviço, preencha também o nome do usuário com que será executado
    • Uma janela para inserir o usuário e senha será apresentada.
      
      
14. Após isso o agent está configurado e irá exibir as mensagens abaixo:
    
    
    
15. Verifique no portal se seu novo Build Agent está instalado e funcionando
    
    

Por hoje é isso! Até a próxima!

Sempre que precisamos de alguma informação, vamos em nosso buscador preferido (Bing) e pesquisamos o que está tirando o sono para resolver aquele problema de um cliente ou até mesmo para matar a curiosidade de algo aleatório. Muitas das respostas que procuramos conseguimos encontrar em Blogs. Penso que muito disso é porque a experiencia, vivência e os problemas encontrados e nem sempre resolvidos pelas pessoas que escrevem, podem ser de maior proveito que um roteiro passo a passo que pode não se encaixar a sua realidade. Porém obviamente não deixando de lado documentações de produtos e referências técnicas que sempre vão se encaixar em qualquer situação.

Por isso estamos aqui. Minha intenção é falar um pouco sobre um ou outro problema que tenho encontrado durante minhas idas e vindas por diferentes clientes e situações cotidianas referentes as tecnologias que trabalho.

Sou Premier Field Engineer de ALM (Application Lifecycle Management) na Microsoft e atualmente moro no Rio de Janeiro. Trabalho em diferentes e grandes clientes com as mais variadas situações e problemas. Ajudo-os com as melhores práticas de ALM utilizando TFS e outras ferramentas e plataformas Microsoft para atender as necessidades de negócio de cada um.

Aqui temos um exemplo de uma parte dos assuntos que quero abordar:

Espero que encontre aqui a resposta ou o caminho de uma, para que durma melhor após resolver o problema que não encontrou resposta no primeiro link de busca.

Um abraço e até logo!