¿Cómo despliega su aplicación web .NET? (Recomendaciones, por favor!)

Recientemente hemos actualizado nuestro sitio web ASP.NET a una aplicación web y estamos sorprendidos por el repentino salto en la dificultad al implementarlo. Teniendo en cuenta lo común que debe ser esta tarea, me preguntaba qué complementos / software utilizan las personas para implementar un proyecto que evoluciona rápidamente y se almacena de forma remota (es decir, un sitio web).

Debe haber una mejor manera que simplemente "Publicar" en Visual Studio y luego tener que enviar manualmente por FTP los archivos que han cambiado. No menos importante porque el sitio se cae cuando estamos cargando nuestros .DLL.

Hay tantas excepciones de archivos complicados que preferiría automatizar el proceso tanto como sea posible, para evitar cargas accidentales.

Con nuestra antigua solución (en nuestro sitio web) utilizamos Dispatch for ASP que sacudió totalmente e hizo todo el proceso con un solo clic. Lamentablemente, no es excelente para las DLL (como se mencionó anteriormente).

Entonces, ¿cómo lo hace tu equipo?

Gracias por cualquier consejo

PD: he leído que se supone que Visual Studio 2010 abordará estas deficiencias en VS2005 / 08, pero hasta entonces ...

Recomiendo encarecidamente utilizar la integración continua.

Utilizamos una combinación de TeamCity para CI, Rake y Albacore para automatizar la compilación.

TeamCity verificará el código de su repositorio de código fuente, luego, utilizando Rake, compilará la aplicación, ejecutará pruebas unitarias e incluso ejecutará los scripts de la base de datos si así lo desea. Después de una compilación exitosa, puede empaquetar su código fuente en un archivo zip o copiarlo en el destino que elija.

Usamos Git, aunque TeamCity funciona con todos los sistemas de control de código fuente.

Usar TeamCity y Rake sería similar a usar CruiseControl y NANT, sin la edición de archivos XML. Por supuesto, puede usar TeamCity con NANT si lo prefiere.

Una muestra corta extraída de un archivo rakefile.rb que realiza la compilación. En mi humilde opinión, más fácil de leer y depurar que un archivo XML.

require 'albacore'
require 'rexml/document'
require 'find'

VERSION_NO = "1.0"

OUTPUT_PATH = "output"
WEBOUTPUT_PATH = "output/web"
ADMINOUTPUT_PATH = "output/admin"

CONFIG = "Release"

WEB_PATH = "app/Company.Website.Web"
ADMIN_PATH = "app/Company.Website.Admin"
PACKAGE_PATH = "build/package"
DB_SCRIPT_PATH = "Company.Website.DB"
SOLUTION = "Company.Website.sln"

ARTIFACTS_PATH = "d:/build/artifacts/"

DEPLOY_WEB_PATH = "d:/deploy/company/website/"
DEPLOY_ADMIN_PATH = "d:/deploy/company/admin/"

task :default => ['setuptest','assemblyinfo','config','msbuild','createdb','sqlcmd','deploy']


task :setuptest do |setup|
  if ENV['BuildNumber'].nil? then ENV['BuildNumber'] = "000" end

  VERSION_NO = VERSION_NO + '.' + ENV['BuildNumber']
  puts 'Version Number : ' + VERSION_NO

  ZIPFILE_WEB = 'Company.Website.Web.' + VERSION_NO
  ZIPFILE_ADMIN = 'Company.Website.Admin.' + VERSION_NO  

  DB_SERVER = "WEB2"
  DB_DATABASE = "Website"  
  CREATEDB_SCRIPT = "app/Company.Website.DB/00CreateDatabaseTEST.sql"
end

  assemblyinfotask do |asm|
    asm.version = VERSION_NO
    asm.company_name = "Company Name"
    asm.copyright = "Copyright 2010"
    asm.output_file = "CommonAssemblyInfo.cs"
  end

  task :config do
    FileUtils.cp 'NHibernate.test.config', 'NHibernate.config'
  end

  msbuildtask do |msb|
    msb.properties = { :configuration => :Debug }
    msb.targets [:Clean, :Build]
    msb.solution = "Company.Website.sln"
  end

  sqlcmdtask :createdb do |sql|
    puts "executing sql scripts..."
    sql.log_level = :verbose
    sql.path_to_command = "sqlcmd.exe"
    sql.server = DB_SERVER
    sql.database = "master"
    sql.scripts << CREATEDB_SCRIPT
  end

  sqlcmdtask do |sql|
    puts "executing sql scripts..."
    sql.log_level = :verbose
    sql.path_to_command = "sqlcmd.exe"
    sql.server = DB_SERVER
    sql.database = DB_DATABASE
    sql.scripts << "app/Company.Website.DB/01CreateTables.sql"
    sql.scripts << "app/Company.Website.DB/02InsertReferenceData.sql"
  end

  task :deployprep do

    FileUtils.remove_dir 'app/Company.Website.Web/obj'
    FileUtils.remove_dir 'app/Company.Website.Admin/obj'

  end

  ziptask :zipweb do |zip|
    puts "creating zip package in " + ZIPFILE_WEB
    zip.directories_to_zip = ["app/Company.Website.Web"]
    zip.output_file = ZIPFILE_WEB  + '.zip'
    zip.output_path = File.dirname(__FILE__)
  end

  ziptask :zipadmin do |zip|
      puts "creating zip package in " + ZIPFILE_ADMIN
    zip.directories_to_zip = ["app/Company.Website.Admin"]
    zip.output_file = ZIPFILE_ADMIN  + '.zip'
    zip.output_path = File.dirname(__FILE__)
  end  

Albacore es un conjunto de tareas de Rake específicamente creadas para implementar aplicaciones .NET.

En Linux, he usado fabric (fabfile.org) y capistrano (capify.org), que son herramientas de automatización para ayudar en los comandos remotos SSH y SCP. Si tiene Cygwin instalado en sus hosts de Windows, debería poder reutilizarlos como herramientas de implementación.

"Publicar" una aplicación web en Visual Studio se puede ejecutar desde la línea de comandos como msbuild "C:\proj\yourprojectpathandfilename.csproj" /deploydir:"C:\some\deploy\dir". El directorio de destino es una aplicación web desplegable.

Las otras respuestas que cubren su pregunta más amplia son buenas. También agregaría que debe mirar varios proyectos de aplicaciones web de código abierto y copiar el proceso de compilación que más le guste.

Estoy de acuerdo con Scott en que esto puede ser muy complicado y fácil de pasar por alto. La estrategia de implementación también es muy específica de la aplicación. Si su aplicación está completamente autocontenida en una carpeta, podría ser más fácil que una aplicación que hace referencia al GAC. Lo que a su vez podría ser más fácil aún que un servidor que necesita mantener múltiples versiones de una aplicación que hace referencia a múltiples versiones de ensamblajes del GAC. No queremos comenzar a hablar sobre archivos de políticas aquí :).

Dicho todo esto, combinar la herramienta de implementación web de Microsoft con el enrutamiento de solicitud de aplicaciones es una buena opción. En IIS7, es posible crear paquetes de instalación utilizando la herramienta. También es posible apuntar la herramienta a una aplicación web y hacer una copia de seguridad de toda la aplicación en una carpeta de archivo de la aplicación. A continuación, puede implementar desde esta carpeta de archivo en un servidor web IIS6 o IIS7 (no se admite IIS5). Usaría el enrutamiento de solicitud de aplicación como Scott sugirió separar en vivo de los sitios web de prueba. Una vez que haya verificado que el sitio web recién publicado es bueno, puede configurar ARR para que se dirija a la nueva versión.

PyroBatchFTP funciona muy bien para esto. Empujará solo los cambios y puede hacer un script para que pueda presionar con un doble clic en un archivo por lotes.

En Vaasnet hemos configurado la solución ideal para nosotros, pero es bastante complicado configurarlo, pero vale la pena usar algunos o todos estos elementos si es posible. Esto es lo que es:

• SVN en todas nuestras máquinas de desarrollo
• SVN en nuestro servidor de compilación / implementación
• Cruisecontrol.net observa los cambios en SVN y construirá y organizará solo los archivos necesarios en una carpeta de ensayo
• usando PyroBatchFTP, nos dirigimos a un sitio de preparación (activado por Cruisecontrol para que ocurra automáticamente)
• usando IIS7 y el Enrutamiento de solicitud de aplicación (ARR) y Reescritura de URL, tenemos la siguiente configuración de preparación / producción:
  • ARR por adelantado dirigirá el tráfico a la instancia 01 o 02, dependiendo de cuál esté 'en vivo' y cuál esté 'en escena'
  • la cuenta FTP siempre está vinculada a la "preparación"
  • Tengo otro mini sitio de administración que intercambiará etapas y vivirá con un solo clic. Cambiar todo con 1 segundo de tiempo de inactividad cero y podemos volver a cambiar si nos damos cuenta de que algo estaba mal con esa versión (aunque es raro ya que podemos probarlo tan fácilmente antes de ponerlo en funcionamiento).

Por lo tanto, el resultado neto nos permite registrarnos en SVN y hacer que se compile automáticamente y se ponga en producción sin ninguna interacción manual. Después de probar nuestra URL provisional y determinar que está lista para comenzar, iniciamos sesión en un sitio simple y con 1 clic, está en vivo.

Para otra forma que no se ha sugerido, lo remito a 'Gu' y a los proyectos de configuración web

Básicamente, esto crea un instalador MSI para su aplicación .NET. Este ejemplo es para VS2005, pero tengo VS2010 y el tipo de proyecto todavía está allí. Esto puede darle mucha personalización si la necesita, o solo la instalación básica si no la necesita.

Personalmente, donde trabajo, simplemente hacemos una implementación de estilo xcopy, pero eventualmente me gustaría entregar un paquete al grupo de servidores, dándoles el control sobre cuándo y cómo se implementa. (Creo que esto también podría facilitar las implementaciones masivas utilizando algo como la política de grupo, pero no estoy muy familiarizado con eso)

Hay muchas formas de desollar este gato, realmente depende de cuánto acceso pueda tener en su servidor. Mi método favorito personal últimamente es configurar un script de compilación dentro del proyecto (típicamente usando MSBUILD) que empaqueta todos los archivos de implementación, luego uso SVN para conectarlos a la producción. Y para versionar los archivos de producción.

En cuanto a la base de datos, la mejor opción es utilizar algún tipo de marco de migración. Una vez más, un montón de esos corriendo y sin una respuesta realmente clara.

Personalmente, solo uso un script vbs que escribí para copiar carpetas de tipos de archivo específicos en el servidor de desarrollo (es decir, omitir archivos cs, etc.).

Cuando trabajé en una gran empresa .com, esto es lo que hicimos con nuestras implementaciones .net.

Todo nuestro código fuente y procedimientos almacenados se almacenaron en SVN. Cada noche, un trabajo de base de datos ejecuta y extrae los procesos almacenados de producción y los desliza en un directorio en SVN para que siempre haya una versión más actual en el control de origen.

El día de la implementación de un proyecto, usaríamos un script nAnt para extraer los proyectos de SVN, hacer una compilación personalizada de los proyectos y extraer cualquier dependencia que estos proyectos necesitaran. Una vez que se ejecutó el script nAnt, se empaquetó en un archivo zip autoextraíble. Los procesos almacenados que estaban asociados con esta implementación se registraron en el control de origen y se actualizó una hoja de distribución de Excel con los scripts para ejecutar y en qué orden.

Cuando se activó el despliegue, el archivo zip autoextraíble se transfirió al servidor donde se inició. Todos los archivos se extrajeron en los directorios correctos y el DBA ejecutó los procesos almacenados en la base de datos de producción.

En una implementación típica que usa este sistema, pasamos de una implementación de cinco a seis horas a menos de una hora o menos.

Buena suerte y espero que esto ayude a algunos a encontrar una manera de implementar su aplicación.

Debe haber una mejor manera que simplemente "Publicar" en Visual Studio y luego tener que enviar manualmente por FTP los archivos que han cambiado.

La navaja de afeitar de Occam suele ser el enfoque preferido: cuanto más simple, mejor. FTP es fácil con poca o ninguna complicación. Algunas personas usan XCOPY, Filezilla o WSFTP, otras pueden usar la herramienta de implementación web de MS (que aún no conozco), pero en general, hay una mejor manera de implementar aplicaciones web ASP.NET (y otras aplicaciones en general). En mi opinión, si se toma en cuenta la implementación desde el comienzo del desarrollo, la implementación se puede integrar con la aplicación web, lo que lo convierte en una implementación relativamente fácil y sin problemas en el futuro.

Como desarrollador de .NET que ha trabajado en varias compañías que desarrollan aplicaciones web ASP.NET que varían en tamaño, complejidad y número de usuarios (desde varios cientos de usuarios hasta decenas de miles), el "despliegue" de la OMI es a menudo el tema más "fluido". Algunas organizaciones lo llevan demasiado lejos en términos de burocracia, mientras que otras no abordan ningún problema con la implementación. En mi experiencia, los problemas con la implementación tienden a caer en 1 o más de 3 categorías en términos de dificultades / fallas:

1. La implementación se ignora / olvida en profundidad durante la fase de diseño: la mayoría de las aplicaciones web tienden a incorporar un servidor web y una base de datos. Más allá del código de la aplicación, tal vez algunos procedimientos almacenados y tablas de bases de datos, la implementación no necesita mucha reflexión. ASP.NET es más que capaz de ayudar en la implementación, pero la mayoría de las veces los desarrolladores se distraen en términos de ejecutar la aplicación real y realizar su tarea, dejando el cómo de la implementación como un problema separado.

2. La implementación es compleja en múltiples sistemas y personas en juego: la complejidad es una perra. Desde MSMQ, procedimientos almacenados T-SQL y disparadores, Reporting Services, mensajería SOAP / XML, autenticación AD, SSAS / SSIS, etc. etc., la cantidad de tecnologías en juego aumenta la cantidad de personas involucradas. Lo peor de todo, todos estos componentes diferentes generalmente son administrados por diferentes entidades dentro de una organización. A menos que todos estén sincronizados entre sí, las implementaciones pueden aumentar su complejidad rápidamente y conducir a múltiples puntos de falla.

3. Pereza, apatía o falta de comunicación y / o gestión: desde poca o ninguna documentación hasta la falta de comunicación y protocolo coordinados, es fácil arruinar un proceso relativamente simple. La implementación debe ser un procedimiento simple con numerosas comprobaciones en su lugar mientras se documenta lo que se hace, pero a menudo nunca es así. La mayoría de la gente solo quiere que el maldito sitio esté funcionando. En mi experiencia, a las personas (no programadoras) realmente no les importa hasta que algo se vuelve realmente fubar. La responsabilidad rara vez recae en una sola persona para hacer el despliegue, ya que nadie realmente quiere ser la razón del fracaso, por lo que la responsabilidad generalmente se dispersa.

Hay tantas excepciones de archivos complicados que preferiría automatizar el proceso tanto como sea posible, para evitar cargas accidentales. Entonces, ¿cómo lo hace tu equipo?

No conozco ningún proveedor disponible para automatizar la implementación, aunque no me sorprendería si hubiera algunos. Probablemente podría escribir una solución a través de VBScript / WMI o una secuencia de comandos por lotes, pero la realidad es que necesita adaptar una solución para sitios ASP.NET más complejos. Sitios simples que consisten en páginas, conectividad de base de datos y nada más, no necesita hacer tanto, así que escale sus esfuerzos de implementación de acuerdo con la complejidad de la aplicación misma.

Hasta ahora, en mi trabajo actual, la implementación aún se realiza a través de FTP y mueve un montón de archivos. Es feo, fácil de fastidiar y no tiene la sensación de tener una historia precisa. Por supuesto, puedes revisar los registros FTP, nadie se molesta en hacerlo. Nuestras aplicaciones son bastante simples sin mucha necesidad más allá de FTP. La forma en que mi equipo implementa nuestras aplicaciones web es realmente poco o nada útil para usted. En cambio, prefiero aprovechar esta oportunidad para sugerir mejores prácticas.

• Asumir nada. Cuentas de usuario, privilegios R / W / X, ACL, firewalls, tiempo (cuándo implementar y cuánto tiempo tiene que hacerlo) y, si es posible, probar la implementación en todos los entornos antes de la "fecha de lanzamiento" final.
• Antes de que el desarrollo realmente comience, factorice la implementación en el desarrollo. Si es un sitio simple, que así sea. Si hay numerosas partes móviles, incorpórelas y construya un plan en el que todos los componentes (código, base de datos, informes, colas, etc.) estén todos en el mismo plan.
• Coordinar con otras paridades y comunicarse de manera efectiva y eficiente.
• Documente tanta información pertinente si es posible.
• Entorno: un servidor web vs. granja web; 32 bits frente a 64 bits; encontrar una manera de monitorear registros / errores / rotar, etc.
• Encuentre (o cree) herramientas que puedan ayudar en la implementación.
• Si es posible para una implementación programable, elija un paradigma y manténgalo. Por ejemplo, si desea utilizar un servidor de base de datos como el medio principal para llevar a cabo el estado de una aplicación, su implementación, acceso y demás, hágalo en la aplicación y manténgalo. Si prefiere leer archivos XML (como web.config) por todos los medios, simplemente manténgase en un paradigma consistente de implementación de la aplicación. Otro ejemplo: algunas organizaciones dejan web.config como un archivo estático en cada entorno que no debe implementarse en otros entornos. El programa de otros web.config de tal manera que se puede implementar en todos los entornos sin error.

Me doy cuenta de que esta publicación puede ser exagerada para la pregunta que se hizo originalmente. Desafortunadamente, la implementación no es algo simple, ya que las aplicaciones pueden variar en complejidad. Apuesto a que la mayoría de las organizaciones que implementan aplicaciones ASP.NET complejas han desarrollado con el tiempo ciertas estrategias que funcionan (al menos) de manera confiable.