To understand the core challenge in deploying updated Drupal releases first we need to consider what makes up a Drupal website. A Drupal website like any web application, in simplest terms, consists of a set of files and a database. The set of files includes, but isn't limited to, image files, text files, php files, style sheets, and java script files, just to name a few.
When files are moved from development to production there is little danger of file name conflicts. Older files in production will intentionally be overwritten by files with the same name that have been updated in development, or new files from development will simply be added to production. This is the normal, typical flow. There is one scenario where a conflict might occur. Generally new files are not added in production. There is one exception. Files uploaded by means of the CCK file field are saved in a predetermined Files folder. If a user uploads a file in production and another user uploads a different file in development, but both users happen to give their uploaded file the same name, a file name conflict will occur. The simplest solution to this unlikely problem is to enforce some kind of file naming convention, which is not a bad idea anyway. But I digress. To re-emphasize, the main point here is that moving files from development to production generally isn't problematic.
Moving the database from development to production, on the other hand, is and presents the more challenging problem. All other additions and changes made in production, other than the files uploaded by means of the CCK file field previously discussed, by default are made to the database. So any content added by a user, any form submitted, any configuration setting changed, any actions in production are all reflected in the database. As is often the case, when developers are making changes to the site in development at the same time that users are making changes in production, the production database and the development database become unsynchronized.
So the crux of the problem is how to preserve the changes made in production while also incorporating the changes we want to keep from development.
- Simply copying the development database to production will overwrite all changes made in production and is not an option.
- Importing those records from development that we want to keep into the production database will result in ID conflicts. For example, suppose a user creates new content in the production environment and a developer creates different new content in the development environment. It is very probable that a record inserted into the production database and a record inserted into the development database, although containing totally different and unrelated data, could be assigned the same ID. When attempting to import, there will be an ID clash between these two records since unique IDs are required. In addition, if we allow the development record to overwrite the production record, thereby losing the production data, any foreign key references that the production record may have had are either now incorrect or orphaned.
- The only viable option is to use some kind of synchronization software that allows us to import the desired records from development without them clashing with records in production, while also maintaining the correct foreign references.
So to reiterate, the basic problem is database synchronization. There are many things at play that cloud the issue and many side tracks to discussing the issue, but at the core, it's always database synchronization.
One of the things that contribute to the "clouding of the issue" is varying complexities of different Drupal sites. Simple sites may not have to worry about any of this, a simple copy and replace of files and database may be all that's needed. For sites that grow a little more in complexity and conflicts arise, many Drupalers will resort to doing things by hand. Using the Drupal CMS, they'll keep track of their configuration changes and content then transfer them to each environment by hand, clicking off the required check marks and copy and pasting, etc. What they're doing, maybe even unbeknownst to them, is saving the changes in the development database and then saving the same changes in the production database, hence keeping their databases in synch. That works fine if you don't have too many changes to do and don?t have to make them too often. But once the site grows and this chore becomes time consuming and error prone, the next logical Drupular step is to look for modules that will ease the job. There are many modules available that attempt to address one or more problems associated with deployments. The Features module partially helps by packaging a well defined selection of changes into a module that is simply deployed in the new environment. But, Features, like all the ones I've researched so far, doesn't capture all the data that potentially will end up in conflict between the development and production databases.
So the basic problem of database synchronization still remains to be solved. The final solution to the database synchronization problem will most likely include the implementation of some well defined work flow processes, some Drupal modules, some customized scripts and some kind of database synchronization software, of which there are many available.
Of all the articles I've read, the following describes the over-arching problem and solutions the best. It is a little dated so I think that the existing modules might be a little more mature, but the problems and the solutions described are classic in the software engineering community.