Step-by-Step Kentico Deployment Guide

Prerequisites, A Pre-Check Before Deployment

Before starting the deployment of your Kentico website, it's essential to ensure that your target environment meets the necessary requirements and that you have chosen an appropriate deployment method. Here’s what you need to know:

• Environment Requirements

  To deploy Kentico successfully, ensure that your target environment meets the following software requirements:

  • Web Server Software: IIS 8.0 or higher.

  • .NET Framework: Version 4.7.2 or later.

  • Database Type and Version: Microsoft SQL Server 2016 or higher, or Azure SQL Database for cloud-based deployments.

  • For detailed environment compatibility information, refer to Kentico's official documentation.
  
  

• Deployment Methods

  There are two main deployment methodologies for Kentico: on-premise deployment and cloud-based deployment. Each has its own setup process and considerations.

• On-Premise Deployment

  On-premise deployment involves setting up a dedicated web server to host the Kentico application. This method requires careful planning of both hardware and software resources.

  • Hardware Considerations: Ensure your server has adequate CPU, memory, and storage to handle the expected traffic and content load. High-availability setups may include multiple servers with load balancing and failover mechanisms.

  • Software Considerations: Install and configure the necessary software, including the correct version of IIS, .NET Framework, and SQL Server. Regularly update and maintain these components to ensure security and performance.

  • Benefits of on-premise deployment include full control over your infrastructure and the ability to customize server configurations to meet specific needs. However, it also requires significant upfront investment and ongoing maintenance.
  
  

• Cloud-Based Deployment

  Cloud-based deployment involves hosting your Kentico application on a cloud platform. This method offers several advantages, including scalability, flexibility, and reduced maintenance overhead.

  • Scalability: Cloud platforms allow you to scale resources up or down based on demand, ensuring optimal performance during traffic spikes or growth periods.

  • Flexibility: Cloud deployment supports a range of services and configurations, enabling you to tailor the environment to your specific requirements.

  • Reduced Maintenance: Cloud providers manage the underlying infrastructure, including hardware maintenance, updates, and security, freeing your team to focus on application development and content management.

  • Popular cloud providers compatible with Kentico include:
  
  

  • Microsoft Azure: Provides robust support for Kentico with easy scalability, high availability, and integration with other Azure services.

  • Amazon Web Services (AWS): Offers a flexible environment for hosting Kentico, with comprehensive tools for monitoring and managing your application.

  • Google Cloud Platform (GCP): Supports Kentico deployment with scalable infrastructure and advanced analytics capabilities.

Choosing between on-premise and cloud-based deployment depends on your business needs, budget, and technical expertise. Cloud-based deployment is generally recommended for its ease of management and scalability, particularly for businesses expecting growth or fluctuating traffic.

By ensuring your environment meets these prerequisites and selecting the right deployment method, you can set the stage for a successful Kentico deployment. Next, we will delve into the detailed steps for deploying Kentico in both environments.

Kentico Deployment Steps

Done with Kentico development? It’s time to deploy it. Here’s how you can do it, a step-by-step guide for you.

1. Project Preparation

   Proper preparation of your Kentico project is critical for a successful deployment. This includes configuring essential project files, setting environment variables, and performing pre-deployment checks to ensure everything is in place for a smooth launch.

   • Configuration Files

     Configuring Kentico project files for the target environment is crucial as it ensures that the application connects correctly to databases, email servers, and other integrations. Here’s a detailed breakdown of the key configuration files you need to edit:

   • web.config

     The web.config file is a central configuration file for your Kentico application, managing settings related to the web server and application behavior.

     • Connection Strings: Configure the connection strings to point to the correct database server. This includes settings for the database name, server address, and authentication details.

       
       <connectionStrings>
           <add name="CMSConnectionString" 
              connectionString="Data Source=your_server;Initial                                            Catalog=your_database;Integrated Security=True;" 
            providerName="System.Data.SqlClient" />
       </connectionStrings>
                                                                       

     • Email Server: Set up the SMTP settings for the email server, including server address, port, and authentication details.

       
       <system.net>
            <mailSettings>
                 <smtp from="your_email@example.com">
                      <network host="smtp.example.com" port="587" userName="your_username" password="your_password" />
                 </smtp>
            </mailSettings>
       </system.net>
                                                                       

        

     • Other Integrations: Configure settings for other integrations like APIs, payment gateways, or external services within the web.config file.

   • App.config (if applicable)

     For projects using specific development frameworks, such as MVC, additional configuration might be required in the App.config file.

   • MVC Configuration:

     Set up routes, controllers, and other MVC-specific settings.

     
     <appSettings>
            <add key="MvcConfig" value="true" />
     </appSettings>
                                                             

     
     

   • Other Framework Settings:

     Configure any other settings specific to the chosen development framework to ensure smooth operation.

   • Settings.txt

     The Settings.txt file includes various environment-specific settings.

     • Environment Settings: Specify settings for different environments (development, staging, production) to ensure the application behaves correctly in each environment.

       
       Environment=Production
       LogLevel=Error
                                                                       

        

   • Environment Variables

     Setting environment variables for sensitive information (e.g., passwords, API keys) enhances security by avoiding hardcoding credentials in configuration files. This can be done in various ways depending on the deployment environment.

     • Windows Environment Variables: Set environment variables through the Windows Control Panel or PowerShell.

       
       [Environment]::SetEnvironmentVariable("API_KEY", "your_api_key", "Machine")
                                                                       

       
       

     • Azure App Service: Configure environment variables in the Azure portal under the Application settings section.

     • AWS Elastic Beanstalk: Set environment variables through the Elastic Beanstalk console under Configuration -> Software.

   • Using environment variables helps keep sensitive information secure and makes it easier to manage settings across different environments.
   
   

   • Pre-Deployment Checks

     Running automated pre-deployment checks is essential to identify potential configuration errors or missing dependencies before deployment. Tools like the Kentico Deployment Assistant can be used to streamline this process.

     • Kentico Deployment Assistant: This tool helps validate configuration settings, ensuring that all required components are correctly configured and that there are no missing dependencies.

     • Automated Scripts: Set up scripts to perform checks on configuration files, database connections, and other critical components to ensure everything is ready for deployment.

   • By preparing your project thoroughly and addressing these key areas, you can minimize the risk of issues during deployment and ensure a successful launch of your Kentico website.
   
   

   • Database Deployment

     Deploying your Kentico database is a critical step in the deployment process. There are two main approaches for deploying the Kentico database: Database Backup and Restore, and Kentico Export/Import. Each method has its own advantages and steps.

     • Database Backup and Restore

       Using the Database Backup and Restore method involves exporting a database backup from the development environment and restoring it on the target server. Here’s how to do it:

       • Export Database Backup:

         • Open SQL Server Management Studio (SSMS).

         • Connect to your development database.

         • Right-click the database you want to back up, select "Tasks," and then "Back Up."

         • Choose the backup type (Full, Differential, Transaction Log) and specify the destination.

         • Click "OK" to create the backup file.

       • Transfer Backup File:

         • Securely transfer the backup file to the target server. Use secure methods such as SFTP or a secure cloud storage service to avoid any potential security risks.

       • Restore Database on Target Server:

         • Open SQL Server Management Studio (SSMS) on the target server.

         • Right-click "Databases" and select "Restore Database."

         • Right-click the database you want to back up, select "Tasks," and then "Back Up."

         • Choose the "Device" option, browse to the backup file, and select it.

         • Configure the restore options as needed and click "OK" to restore the database.

       • Verify the Restoration:

         • Check the restored database to ensure all data and configurations are correctly imported.

     • Kentico Export/Import

       Kentico’s built-in export/import functionality allows you to transfer site data and configuration from the development environment to the target server.

       • Export Site from Development Environment:

         • Log in to the Kentico administration interface in your development environment.

         • Navigate to the "Sites" application.

         • Select the site you want to export and click "Export."

         • Follow the prompts to select the data and objects you want to export.

         • Save the export package file.

       • Transfer Export Package:

         • Securely transfer the export package file to the target server using secure methods like SFTP or secure cloud storage.

       • Import Site on Target Server:

         • Log in to the Kentico administration interface on the target server.

         • Navigate to the "Sites" application and click "Import."

         • Browse to the exported package file and select it.

         • Follow the prompts to import the site data and configurations.

       • Verify the Import:

         • Check the imported site to ensure all data and configurations are correctly transferred.

     • Security Considerations

       Ensuring database security during deployment is vital. Follow these best practices to maintain security:

       • Strong Passwords: Use strong, complex passwords for database user accounts. Avoid using default or easily guessable passwords.
       • Least Privilege Access: Grant database users the least privilege necessary to perform their tasks. Avoid giving excessive permissions that could be exploited.
       • Regular Backups: Implement regular backup schedules to ensure you can recover data in case of corruption or loss. Store backups securely and verify their integrity regularly.
       • Secure Transfer: When transferring database backups or export packages, use secure methods such as SFTP, HTTPS, or secure cloud storage to prevent unauthorized access.
     • By following these deployment options and security considerations, you can ensure a smooth and secure database deployment for your Kentico project. Next, we will cover the steps for configuring and launching your Kentico site after deployment.
     
     

   • Web Application Deployment

     Deploying the Kentico web application involves transferring the application files to the target server and configuring the web server. Here’s a detailed guide on the various deployment methods, IIS configuration, and setting permissions and ownership.

     1. Deployment Methods

        There are several methods to deploy the Kentico web application files to the target server, each suitable for different project sizes and requirements.

     2. FTP Upload

        Using an FTP client to upload website files is a straightforward method for smaller projects or initial setups.

        • Prepare FTP Client: Install an FTP client like FileZilla.

        • Connect to Server: Enter the FTP server address, username, and password provided by your hosting provider.

        • Upload Files: Navigate to your local Kentico web application folder, select all files, and drag them to the target directory on the server.

        • Verify Upload: Ensure all files are uploaded correctly and check for any transfer errors.

     3. Web Deploy

        Microsoft Web Deploy is a powerful tool for deploying web applications, especially suitable for larger projects.

        • Install Web Deploy: Ensure that Web Deploy is installed on both the development and target servers.

        • Create Deployment Package: In Visual Studio, right-click the Kentico project, select "Publish," and choose "Web Deploy" as the publish method. Configure the settings and create a deployment package.

        • Deploy Package: On the target server, use the Web Deploy command-line tool or IIS Manager to import and deploy the package.

        • Verify Deployment: Check the website to ensure all files and configurations are correctly deployed.

     4. Version Control Integration

        Integrating deployment with version control systems like Git allows for automated deployments and rollback capabilities.

        • Set Up Repository: Ensure your Kentico project is stored in a version control repository (e.g., GitHub, GitLab).

        • Configure CI/CD Pipeline: Use a CI/CD tool like Jenkins, Azure DevOps, or GitHub Actions to automate the deployment process. Configure the pipeline to build, test, and deploy the application.

        • Automated Deployments: Set up automated triggers for deployments, such as commits to the main branch or manual triggers for staging and production environments.

        • Rollback Capabilities: Implement rollback capabilities to revert to previous versions if deployment issues occur.

     5. IIS Configuration

        Configuring Internet Information Services (IIS) is crucial for running Kentico on Windows servers. Here’s a step-by-step guide:

        • Install IIS: Ensure IIS is installed and enabled on your Windows server.

        • Set Up Application Pool:

          • Open IIS Manager.

          • Right-click "Application Pools" and select "Add Application Pool."

          • Name the pool (e.g., "KenticoAppPool"), select .NET CLR Version 4.0, and set the Managed Pipeline Mode to Integrated.

        • Create Website:

          • Right-click "Sites" and select "Add Website."

          • Enter a site name, select the physical path of the Kentico web application, and choose the application pool created earlier.

          • Assign a port number or domain name for the site.

        • Configure Virtual Directories:

          • Right-click the website and select "Add Virtual Directory."

          • Set the alias and physical path for any additional virtual directories required by Kentico.

        • Handler Mappings:

          • Ensure that the correct handler mappings are set for ASP.NET applications.

          • Navigate to the website in IIS Manager, open "Handler Mappings," and verify that .NET handlers are correctly configured.

     6. Alternative Web Server Configurations

        For non-Windows environments, consider using web servers like Apache or Nginx. These configurations are less common for Kentico but can be used with proper setup and configuration of the .NET Core runtime.

     7. Permissions and Ownership

        Setting appropriate permissions and ownership for the deployed web application files ensures that Kentico has the necessary access to resources.

        • File Permissions:

          • Navigate to the root folder of your Kentico web application.

          • Right-click the folder, select "Properties," and go to the "Security" tab.

          • Click "Edit" and add the IIS_IUSRS group, granting Modify, Read & Execute, List Folder Contents, Read, and Write permissions.

        • Ownership:

          • Ensure that the web application files are owned by the appropriate user or group that runs the IIS application pool.

          • To change ownership, right-click the root folder, select "Properties," go to the "Security" tab, and click "Advanced."

          • Click "Change" next to the Owner field, enter the user or group, and apply the changes.

        • Special Permissions:

          • Ensure that any special directories (e.g., logs, cache) have the necessary write permissions for the IIS application pool user.

        • By following these deployment methods, configuring IIS properly, and setting the correct permissions and ownership, you can ensure a successful and secure deployment of your Kentico web application.
        
        

   • Post-Deployment Tasks

     After deploying your Kentico website, several critical post-deployment tasks must be completed to ensure your application runs smoothly and securely. Here’s a detailed guide on configuring the application pool identity, verifying database permissions, updating URLs, setting up virtual scheduling, configuring caching, implementing security measures, and verifying content functionality.

     1. Application Pool Identity

        The application pool identity in IIS determines the user account under which the Kentico application runs. Properly configuring this identity is crucial for security and functionality.

        • Open IIS Manager:

          • Navigate to the Application Pools section.

        • Select Application Pool:

          • Right-click the application pool used by your Kentico site (e.g., "KenticoAppPool") and select "Advanced Settings."

        • Set Identity:

          • Under the "Process Model" section, find the "Identity" property and click the "…" button.

          • Choose a predefined identity (e.g., "ApplicationPoolIdentity") or set a custom account with necessary permissions.

        • Apply Changes:

          • Click "OK" to save the changes and ensure the application pool identity is set correctly.

     2. Database Permissions

        Verifying and granting appropriate database permissions to the user account associated with the application pool ensures that the Kentico application can access and modify database content.

        • Connect to Database:

          • Use SQL Server Management Studio (SSMS) to connect to your database server.

        • Assign Permissions:

          • Navigate to the Security section and find the login associated with your application pool identity.

          • Right-click the login and select "Properties."

          • Under "User Mapping," map the login to your Kentico database and assign the necessary roles (e.g., db_owner).

        • Verify Permissions:

          • Ensure the account has the required permissions to read, write, and modify database content.

     3. URL Configuration

        Updating website URLs within the Kentico administration interface is essential to ensure that all links and paths are correct after deployment.

        • Log in to Kentico Admin Interface:

          • Navigate to the Sites application.

        • Update URLs:

          • Select your site and update the primary domain and any other URLs to match the new environment.

        • Verify Changes:

          • Ensure all links and paths are correctly updated and functional.

     4. Virtual Scheduling

        If using scheduled tasks within Kentico (e.g., for automated content publishing), ensure they are configured correctly for the new server environment.

        • Navigate to Scheduled Tasks:

          • In the Kentico admin interface, go to the Scheduled Tasks application.

        • Adjust Task Schedules:

          • Review and adjust task schedules as needed to match the new server environment.

        • Set Security Contexts:

          • Ensure that tasks run under the correct security context and have the necessary permissions to execute.

     5. Caching Configuration

        Configuring caching mechanisms within Kentico can significantly improve performance on the deployment server.

        • Access Caching Settings:

          • Navigate to the Settings application in the Kentico admin interface.

        • Adjust Cache Expiration:

          • Set appropriate cache expiration times for different content types.

        • Enable Caching Features:

          • Enable specific caching features like output caching, data caching, and client-side caching to optimize performance.

     6. Security Measures

        Implementing security best practices after deployment is crucial for protecting your Kentico application.

        • Enable HTTPS:

          • Configure your web server to use HTTPS for secure communication. Obtain and install an SSL certificate if necessary.

        • Configure Kentico Security Features:

          • Set up user roles and permissions to restrict access to sensitive areas.

          • Enable security features like two-factor authentication for enhanced protection.

        • Run Security Scans:

          • Use security scanning tools to identify potential vulnerabilities and address any issues.

     7. Content Verification

        Thoroughly testing all content functionality and layout after deployment ensures everything renders and behaves as expected on the live website.

        • Test Content:

          • Review all pages, content items, and interactive elements to ensure they display and function correctly.

        • Check Layout:

          • Verify that the website layout is consistent and responsive across different devices and browsers.

        • Functional Testing:

          • Test all forms, links, and integrations to ensure they work as intended.

        • By following these post-deployment tasks, you can ensure your Kentico website is secure, functional, and optimized for performance. Proper configuration and thorough testing are essential for a successful launch and ongoing site stability.
        
        

   • Verification and Testing

     Comprehensive testing is crucial after deploying your Kentico website. Thorough testing ensures that all aspects of your site function correctly, providing a seamless user experience and maintaining security. Identifying and fixing issues before the website goes live can save time and resources, preventing potential problems that could affect users and business operations.

     1. Functionality Testing

        Functionality testing involves verifying that all core functionalities of the website work as expected. This includes:

        • Forms: Test all forms on your site, including contact forms, subscription forms, and any custom forms. Ensure they submit correctly, trigger appropriate actions, and store or send data as intended.

        • Content Pages: Navigate through all content pages to check for broken links, missing images, and accurate display of text and media.

        • E-commerce Features: If your site includes e-commerce capabilities, test the entire shopping experience, from product browsing to checkout and payment processing. Ensure that the cart, payment gateway, and order confirmation functionalities work seamlessly.

        • Third-Party Integrations: Verify that integrations with third-party systems, such as CRM, ERP, or marketing automation tools, are functioning correctly and data flows as expected.

     2. Performance Testing

        Performance testing ensures that your website loads quickly and handles user traffic efficiently. Use tools and techniques to assess your site's performance:

        • Load Testing: Simulate user traffic to evaluate how the website performs under various load conditions. Tools like Apache JMeter and LoadRunner can help with this.

        • Speed Testing: Measure page load times using tools like Google PageSpeed Insights or GTmetrix. Identify and address performance bottlenecks, such as unoptimized images or slow server response times.

        • Scalability Testing: Ensure the website can scale to handle increased traffic during peak periods.

     3. Security Testing

        Security testing is essential to protect your website from potential threats. Run security scans to identify vulnerabilities and implement necessary measures to address them:

        • Vulnerability Scanners: Use tools like OWASP ZAP, Nessus, or Acunetix to scan for common security issues, such as SQL injection, cross-site scripting (XSS), and insecure configurations.

        • Penetration Testing: Conduct manual penetration testing to identify security weaknesses that automated tools might miss.

        • Security Features Verification: Ensure that security features like HTTPS, user authentication, and role-based access controls are correctly configured and functioning.

     4. Cross-Browser Testing

        Cross-browser testing ensures that your website's functionality and layout are consistent across different web browsers and devices, providing a seamless user experience for all users:

        • Browser Compatibility: Test your site on major web browsers, including Chrome, Firefox, Safari, Edge, and Internet Explorer. Check for consistent rendering and functionality.

        • Device Compatibility: Test your website on various devices, including desktops, tablets, and smartphones, to ensure responsive design and optimal performance.

        • Automated Testing Tools: Use tools like BrowserStack or Sauce Labs to automate cross-browser testing and cover a wide range of browsers and devices efficiently.

     5. By conducting these tests, you can ensure that your Kentico website is robust, secure, and ready to deliver an excellent user experience. Comprehensive verification and testing are critical steps to launch a successful and reliable website.
     
     

Some Advanced Considerations To Keep in Mind

As your Kentico website grows, advanced deployment techniques can streamline and enhance your deployment strategy.

1. Deployment Scripting

   Deployment scripting automates repetitive tasks, ensuring consistency and reducing human error. Popular tools include:

   • PowerShell: Automates tasks on Windows servers, such as copying files and configuring IIS.

   • Bash: Automates tasks on Linux servers.

   • Microsoft Web Deploy: Scripts to automate web application deployments.

   • Scripts can automate file transfers, set environment variables, and configure servers, making deployments more efficient.
   
   

2. CI/CD Pipeline Integration

   Continuous Integration/Continuous Delivery (CI/CD) automates code integration and delivery, enabling faster and more reliable deployments.

   • Benefits: Automates build, test, and deployment processes, ensuring consistent quality and faster releases.

   • Tools: Jenkins, Azure DevOps, GitHub Actions, and GitLab CI.

   • Integration: Set up automated builds for Kentico, run tests, and deploy to the target environment, ensuring each change is tested and deployed consistently.

3. Load Balancing

   Load balancing ensures high availability and reliability by distributing traffic across multiple servers.

   • Implementation: Use load balancers like NGINX or AWS Elastic Load Balancing.

   • Configuration: Distribute incoming traffic to ensure the website remains accessible even if one server fails.

   • By implementing these advanced techniques, you can ensure a more efficient, reliable, and scalable Kentico deployment process.
   
   

Here Are Some Troubleshooting Tips To Help You

Deploying a Kentico website can sometimes encounter issues. Here are some common problems and their solutions:

1. Connection String Errors

   Connection string errors can prevent your application from connecting to the database.

   • Solution: Verify the connection string in the web.config file. Ensure the server name, database name, username, and password are correct. Use a database client to test connectivity.

2. Permission-Related Issues

   Permission-related issues can cause functionality problems if the application can't access necessary resources.

   • Solution: Ensure the IIS application pool identity has the correct permissions on the file system and database. Check folder permissions and database user roles.

3. Website Functionality Issues After Deployment

   Website functionality issues may arise due to configuration mismatches or missing files.

   • Solution: Verify all necessary files were uploaded. Check the web.config and other configuration files for correct settings. Review application logs for error details and resolve accordingly.

4. Security Vulnerabilities Identified During Testing

   Security vulnerabilities need immediate attention to protect your site.

   • Solution: Address vulnerabilities identified by security scans. Implement HTTPS, configure secure user roles, and update software to patch known issues. Use tools like OWASP ZAP to run security tests and validate fixes.

By following these troubleshooting tips, you can quickly identify and resolve common deployment issues, ensuring a smooth and secure Kentico website launch.

Leave It To The Experts

At DotStark, a leading Kentico development company, we specialize in delivering seamless Kentico deployments and comprehensive support to ensure your website operates flawlessly.

Our team has extensive experience in Kentico deployments, ensuring your project is set up correctly from the start.

We handle everything from initial setup to post-deployment tasks, including configuring application pools, setting database permissions, and optimizing caching mechanisms.

Understanding that every business is unique, we provide tailored deployment strategies to meet your specific needs, whether you're opting for on-premise or cloud-based solutions.

Our expertise in Kentico Development Best Practices guarantees a smooth and efficient deployment process, allowing you to focus on your core business activities while we take care of the technical details.