Como você implanta seus aplicativos ASP.NET em servidores ativos?

Estou procurando diferentes técnicas / ferramentas que você usa para implantar um projeto de aplicativo da web ASP.NET ( NÃO ASP.NET) para produção?

Estou particularmente interessado no fluxo de trabalho que está acontecendo entre o momento em que seu servidor Continuous Integration Build descarta os binários em algum local e o momento em que a primeira solicitação do usuário atinge esses binários.

1. Você está usando algumas ferramentas específicas ou apenas XCOPY? Como o aplicativo é empacotado (ZIP, MSI, ...)?

2. Quando um aplicativo é implantado pela primeira vez, como você configura o App Pool e o diretório virtual (você os cria manualmente ou com alguma ferramenta)?

3. Quando um recurso estático é alterado (CSS, JS ou arquivo de imagem), você reimplanta o aplicativo inteiro ou apenas o recurso modificado? E quando uma página assembly / ASPX muda?

4. Você acompanha todas as versões implantadas de um determinado aplicativo e, caso algo dê errado, você tem procedimentos para restaurar o aplicativo a um estado anterior de funcionamento conhecido?

Sinta-se à vontade para completar a lista anterior.

E aqui está o que usamos para implantar nossos aplicativos ASP.NET:

1. Adicionamos um projeto de implantação da Web à solução e o configuramos para construir o aplicativo da Web ASP.NET
2. Adicionamos um Projeto de instalação ( NÃO Projeto de configuração da Web) à solução e o configuramos para obter a saída do Projeto de implantação da Web
3. Adicionamos uma ação de instalação personalizada e, no evento OnInstall, executamos um assembly .NET de construção personalizada que cria um pool de aplicativos e um diretório virtual no IIS usando System.DirectoryServices.DirectoryEntry (esta tarefa é executada apenas na primeira vez que um aplicativo é implantado) . Oferecemos suporte a vários sites da Web no IIS, autenticação para diretórios virtuais e configuração de identidades para pools de aplicativos.
4. Adicionamos uma tarefa personalizada no TFS para construir o projeto de instalação (o TFS não oferece suporte a projetos de instalação, portanto, tivemos que usar devenv.exe para construir o MSI)
5. O MSI é instalado no servidor ativo (se houver uma versão anterior do MSI, ela é desinstalada primeiro)

Temos todo o nosso código implantado em MSIs usando Setup Factory. Se algo precisa mudar, nós reimplantamos toda a solução. Isso parece um exagero para um arquivo css, mas mantém absolutamente todos os ambientes em sincronia e sabemos exatamente o que está em produção (implantamos em todos os ambientes de teste e uat da mesma forma).

Fazemos implantação contínua para os servidores ativos, portanto, não usamos projetos de instalação; temos algo mais como CI:

• compilações de servidor de compilação "ao vivo" da fonte aprovada (não o "HEAD" do repo)
• (depois de fazer um backup ;-p)
• robocopy publica em um servidor de teste ("ao vivo", mas não no cluster F5)
• validação final feita no servidor de teste, geralmente com hacks de "hosts" para emular tudo o mais próximo possível
• robocopy / L é usado automaticamente para distribuir uma lista das mudanças no próximo "push", para alertar sobre qualquer idiotice
• como parte de um processo programado, o cluster é reiniciado, implantando nos nós do cluster por meio de robocópia (enquanto eles estão fora do cluster)

robocopy garante automaticamente que apenas as mudanças sejam implementadas.

Re o App Pool etc; Eu adoraria que isso fosse automatizado ( veja esta pergunta ), mas no momento é manual. Eu realmente quero mudar isso, no entanto.

(provavelmente ajuda ter nosso próprio data-center e farm de servidores "no local", para que não tenhamos que cruzar muitos obstáculos)

Local na rede Internet

Deployer: http://www.codeproject.com/KB/install/deployer.aspx

Publico o site em uma pasta local, compasso e carrego no FTP. O Deployer no servidor extrai o zip, substitui os valores de configuração (no Web.Config e em outros arquivos) e pronto.

É claro que, para a primeira execução, você precisa se conectar ao servidor e configurar o IIS WebSite e o banco de dados, mas depois disso publicar as atualizações é fácil.

Base de dados

Para manter os bancos de dados sincronizados, eu uso http://www.red-gate.com/products/sql-development/sql-compare/

Se o servidor estiver atrás de vários roteadores e você não conseguir se conectar diretamente (que é um requisito do SQL Compare), use https://secure.logmein.com/products/hamachi2/ para criar VPN.

Implantei principalmente aplicativos ASP.NET em servidores Linux e reimplantei tudo até mesmo para a menor alteração. Aqui está meu fluxo de trabalho padrão:

• Eu uso um repositório de código-fonte (como o Subversion)
• No servidor, tenho um script bash que faz o seguinte:
  • Verifica o código mais recente
  • Faz um build (cria as DLLs)
  • Filtra os arquivos até o essencial (remove arquivos de código, por exemplo)
  • Faz backup do banco de dados
  • Implementa os arquivos no servidor web em um diretório nomeado com a data atual
  • Atualiza o banco de dados se um novo esquema for incluído na implantação
  • Torna a nova instalação a padrão para que seja servida com o próximo hit

A verificação é feita com a versão de linha de comando do Subversion e a compilação é feita com xbuild (msbuild trabalho semelhante do projeto Mono). A maior parte da mágica é feita no ReleaseIt.

No meu servidor de desenvolvimento, tenho essencialmente integração contínua, mas no lado da produção, na verdade, faço SSH no servidor e inicio a implantação manualmente, executando o script. Meu script é habilmente chamado de 'implantar', então é isso que eu digito no prompt do bash. Eu sou muito criativo Não.

Na produção, tenho que digitar 'implantar' duas vezes: uma para fazer o check-out, construir e implantar em um diretório datado e uma vez para tornar esse diretório a instância padrão. Como os diretórios estão desatualizados, posso reverter para qualquer implantação anterior simplesmente digitando 'implantar' de dentro do diretório relevante.

A implantação inicial leva alguns minutos e a reversão para uma versão anterior leva alguns segundos.

Tem sido uma boa solução para mim e conta apenas com os três utilitários de linha de comando (svn, xbuild e releaseit), o cliente DB, SSH e Bash.

Eu realmente preciso atualizar a cópia do ReleaseIt no CodePlex algum dia:

http://releaseit.codeplex.com/

XCopy simples para ASP.NET. Compacte-o, envie um sftp ao servidor e extraia no local certo. Para a primeira implantação, configuração manual do IIS

Respondendo suas perguntas:

1. XCopy
2. Manualmente
3. Para recursos estáticos, implementamos apenas o recurso alterado.
   Para DLLs, implantamos as páginas DLL e ASPX alteradas.
4. Sim e sim.

Manter as coisas boas e simples nos salvou de muitas dores de cabeça até agora.

Você está usando algumas ferramentas específicas ou apenas XCOPY? Como o aplicativo é empacotado (ZIP, MSI, ...)?

Como desenvolvedor da BuildMaster , é isso que eu uso naturalmente. Todos os aplicativos são desenvolvidos e empacotados na ferramenta como artefatos, que são armazenados internamente como arquivos ZIP.

Quando um aplicativo é implantado pela primeira vez, como você configura o App Pool e o diretório virtual (você os cria manualmente ou com alguma ferramenta)?

Manualmente - criamos um controle de mudança dentro da ferramenta que nos lembra as etapas exatas a serem executadas em ambientes futuros conforme o aplicativo se move através de seus ambientes de teste. Isso também pode ser automatizado com um script PowerShell simples, mas não adicionamos novos aplicativos com muita frequência, por isso é tão fácil gastar o 1 minuto que leva para criar o site manualmente.

Quando um recurso estático é alterado (CSS, JS ou arquivo de imagem), você reimplanta o aplicativo inteiro ou apenas o recurso modificado? E quando uma página assembly / ASPX muda?

Por padrão, o processo de implantação de artefatos é configurado de forma que apenas os arquivos modificados sejam transferidos para o servidor de destino - isso inclui tudo, desde arquivos CSS, arquivos JavaScript, páginas ASPX e assemblies vinculados.

Você acompanha todas as versões implantadas de um determinado aplicativo e, caso algo dê errado, você tem procedimentos para restaurar o aplicativo a um estado anterior de funcionamento conhecido?

Sim, a BuildMaster cuida de tudo isso para nós. A restauração é quase sempre tão simples quanto a reexecução de uma promoção de construção antiga, mas às vezes as alterações do banco de dados precisam ser restauradas manualmente e pode ocorrer perda de dados. O processo básico de reversão é detalhado aqui: http://inedo.com/support/tutorials/performing-a-deployment-rollback-with-buildmaster

projetos de instalação / configuração da web - para que você possa desinstalá-los facilmente se algo der errado

Unfold é uma solução de implantação tipo capistrano que escrevi para aplicativos .net. É o que usamos em todos os nossos projetos e é uma solução muito flexível. Ele resolve a maioria dos problemas típicos de aplicativos .net, conforme explicado nesta postagem de blog de Rob Conery.

• ele vem com um bom comportamento "padrão", no sentido de que faz muitas coisas padrão para você: obter o código do controle de origem, construir, criar o pool de aplicativos, configurar o IIS, etc.
• lançamentos com base no que está no controle de origem
• possui ganchos de tarefas , então o comportamento padrão pode ser facilmente estendido ou alterado
• tem rollback
• é tudo powerhell , então não há dependências externas
• ele usa o controle remoto PowerShell para acessar máquinas remotas

Aqui está uma introdução e alguns outros posts do blog.

Portanto, para responder às perguntas acima:

• Como o aplicativo é empacotado (ZIP, MSI, ...)?

  Git (ou outro scm) é a maneira padrão de obter o aplicativo na máquina de destino. Alternativamente, você pode realizar uma compilação local e copiar o resultado através da conexão remota Powereshell

• Quando um aplicativo é implantado pela primeira vez, como você configura o App Pool e o diretório virtual (você os cria manualmente ou com alguma ferramenta)?

  Unfold configura o pool de aplicativos e o aplicativo do site usando o módulo de administração da Web da Powershell. Ele permite que nós (e você) modifiquemos qualquer aspecto do pool de aplicativos ou site

• Quando um recurso estático é alterado (CSS, JS ou arquivo de imagem), você reimplanta o aplicativo inteiro ou apenas o recurso modificado? E quando uma página assembly / ASPX muda?

  Sim, desdobra faz isso, qualquer implantação é instalada ao lado das outras. Dessa forma, podemos facilmente reverter quando algo der errado. Também nos permite rastrear facilmente uma versão implantada até uma revisão de controle de origem.

• Você acompanha todas as versões implantadas de um determinado aplicativo?

  Sim, o desdobrar mantém versões antigas. Nem todas as versões, mas várias versões. Isso torna a reversão quase trivial.

Temos aprimorado nosso processo de lançamento no ano passado e agora temos tudo sob controle. Estou usando o Jenkins para gerenciar todas as nossas compilações e lançamentos automatizados, mas tenho certeza de que você pode usar TeamCity ou CruiseControl.

Portanto, após o check-in, nossa compilação "normal" faz o seguinte:

• Jenkins faz uma atualização de SVN para buscar a versão mais recente do código
• Uma restauração de pacote NuGet é executada em nosso próprio repositório NuGet local
• O aplicativo é compilado usando MsBuild. Configurar isso é uma aventura, porque você precisa instalar o MsBuild correto e, em seguida, as DLLs ASP.NET e MVC em sua caixa de construção. (Como uma nota lateral, quando eu tinha<MvcBuildViews>true</MvcBuildViews> entrei em meus arquivos .csproj para compilar as visualizações, o msbuild estava travando aleatoriamente, então eu tive que desativá-lo)
• Depois que o código é compilado, os testes de unidade são executados (estou usando o nunit para isso, mas você pode usar o que quiser)
• Se todos os testes de unidade forem aprovados, interrompo o pool de aplicativos IIS, implanto o aplicativo localmente (apenas alguns comandos XCOPY básicos para copiar os arquivos necessários) e reinicio o IIS (tive problemas com o bloqueio de arquivos do IIS e isso resolveu isto)
• Tenho arquivos web.config separados para cada ambiente; dev, uat, prod. (Tentei usar o material de transformação da web com pouco sucesso). Portanto, o arquivo web.config correto também é copiado entre
• Em seguida, uso o PhantomJS para executar vários testes de IU. Também faz várias capturas de tela em diferentes resoluções (celular, desktop) e estampa cada captura de tela com algumas informações (título da página, resolução). Jenkins tem um ótimo suporte para lidar com essas capturas de tela e elas são salvas como parte da construção
• Depois que os testes de interface de usuário de integração passam, a construção é bem-sucedida

Se alguém clicar em "Implementar no UAT":

• Se a última compilação foi bem-sucedida, o Jenkins faz outra atualização do SVN
• O aplicativo é compilado usando uma configuração RELEASE
• Um diretório "www" é criado e o aplicativo é copiado para ele
• Eu então uso o winscp para sincronizar o sistema de arquivos entre a caixa de compilação e o UAT
• Eu envio uma solicitação HTTP para o servidor UAT e certifico-me de receber um 200
• Esta revisão está marcada no SVN como UAT-datetime
• Se chegamos até aqui, a construção foi bem-sucedida!

Quando clicamos em "Deploy to Prod":

• O usuário seleciona uma etiqueta UAT que foi criada anteriormente
• A tag é "trocada" para
• O código é compilado e sincronizado com o servidor Prod
• Solicitação Http para servidor Prod
• Esta revisão está marcada no SVN como Prod-datetime
• O lançamento é compactado e armazenado

A produção completa leva cerca de 30 segundos, o que me deixa muito, muito feliz.

Vantagens para esta solução:

• É rápido
• Os testes de unidade devem detectar erros de lógica
• Quando um bug da IU entra em produção, as capturas de tela provavelmente mostrarão qual revisão # causou isso
• UAT e Prod são mantidos em sincronia
• Jenkins mostra um ótimo histórico de lançamentos para UAT e Prod com todas as mensagens de commit
• Os lançamentos UAT e Prod são marcados automaticamente
• Você pode ver quando os lançamentos acontecem e quem os fez

As principais desvantagens desta solução são:

• Sempre que você faz um release para o Prod, precisa fazer um release para o UAT. Esta foi uma decisão consciente que tomamos porque queríamos sempre garantir que o UAT esteja sempre atualizado com o Prod. Ainda assim, é uma dor.
• Existem alguns arquivos de configuração flutuando. Tentei ter tudo no Jenkins, mas há alguns arquivos em lote de suporte necessários como parte do processo. (Eles também são registrados).
• Os scripts de atualização e downgrade do banco de dados fazem parte do aplicativo e são executados na inicialização do aplicativo. Funciona (principalmente), mas é uma dor.

Adoraria ouvir outras melhorias possíveis!

Em 2009, de onde vem esta resposta, usamos CruiseControl.net para nossas compilações de integração contínua, que também gerou Release Media.

A partir daí, usamos o software Smart Sync para comparar com um servidor de produção que estava fora do conjunto de balanceamento de carga e movemos as alterações para cima.

Finalmente, depois de validar o lançamento, rodamos um script DOS que usava principalmente o RoboCopy para sincronizar o código com os servidores ativos, parando / iniciando o IIS durante o processo.

Na última empresa em que trabalhei, costumávamos implantar usando um arquivo em lote rSync para fazer upload apenas das alterações desde o último upload. A beleza do rSync é que você pode adicionar listas de exclusão para excluir arquivos específicos ou padrões de nome de arquivo. Portanto, excluir todos os nossos arquivos .cs, arquivos de solução e de projeto é realmente fácil, por exemplo.

Estávamos usando o TortoiseSVN para controle de versão, por isso foi bom poder escrever em vários comandos SVN para realizar o seguinte:

• Primeiro, verifique se o usuário tem a revisão mais recente. Caso contrário, solicite a atualização ou execute a atualização imediatamente.
• Baixe um arquivo de texto do servidor chamado "synclog.txt" que detalha quem é o usuário SVN, qual número de revisão ele está enviando e a data e hora do envio. Anexe uma nova linha para o upload atual e envie-a de volta ao servidor junto com os arquivos alterados. Isso torna extremamente fácil descobrir para qual versão do site reverter, caso um upload cause problemas.

Além disso, há um segundo arquivo em lote que apenas verifica as diferenças de arquivo no servidor ativo. Isso pode destacar o problema comum em que alguém carrega, mas não confirma suas alterações no SVN. Combinado com o log de sincronização mencionado acima, podemos descobrir quem é o provável culpado e pedir a eles que enviem seu trabalho.

E, por último, o rSync permite que você faça um backup dos arquivos que foram substituídos durante o upload. Mandamos movê-los para uma pasta de backup. Portanto, se você de repente percebeu que alguns dos arquivos não deveriam ter sido sobrescritos, você pode encontrar a última versão de backup de cada arquivo nessa pasta.

Embora a solução parecesse um pouco desajeitada na época, passei a apreciá-la muito mais ao trabalhar em ambientes onde o método de upload é muito menos elegante ou fácil (desktop remoto, copie e cole o site inteiro, por exemplo) .

Eu recomendo NÃO apenas sobrescrever os arquivos de aplicativos existentes, mas em vez disso, criar um diretório por versão e apontar novamente o aplicativo IIS para o novo caminho. Isso tem vários benefícios:

• Rápido para reverter se necessário
• Não há necessidade de parar o IIS ou o pool de aplicativos para evitar problemas de bloqueio
• Nenhum risco de arquivos antigos causar problemas
• Tempo de inatividade mais ou menos zero (geralmente apenas uma pausa nas inicializações do novo appdomain)

O único problema que tivemos é o armazenamento de recursos em cache se você não reiniciar o pool de aplicativos e confiar na troca automática de appdomain.