The App Gallery contains both ASP.NET, Java, Node JS, Python and PHP applications that follow the Web Application Gallery Principles .

Developers follow four steps to submit an application to the Web Application Gallery.

STEP 1: APPLY WEB APP GALLERY PRINCIPLES

First, developers must review and apply the Web Application Gallery Principles to their applications. These Principles reflect the Web Application Gallery’s goals to deliver a quality, safe user experience that is consistent across platforms supported by Azure Platform Installer.

STEP 2: TUNE APPLICATION BASED ON BEST PRACTICES AND PRINCIPLES

Azure Websites uses IIS Web server under the hood. Developers can visit IIS.NET for best practices in running applications on IIS. For ASP.NET applications, developer can start with a snapshot of ASP.NET Technical Resources or check out the Running ASP.NET Applications on IIS section. For PHP applications, developers can browse the Running PHP Applications for articles on how to make PHP applications work well on IIS. Guidance for PHP developers includes how to use web.config to set default document and static rewrite rules. IIS.NET also hosts guidance for any application developer on Windows, such as Securing Content on IIS Using File System ACLs.

If your application is compatible with IIS and does not require these conditions then it will work on Azure websites platform:

-      php configuration that cannot be updated in a .user.ini or

-      Special Python/Java configuration required at the server level may not be supported

-      IIS configuration that cannot be updated with web.config.

-      Azure websites does not allow special software to be installed on the virtual machines hosting the websites.

STEP 3: PACKAGE USING WEB DEPLOY

After tuning the application package with best practices, the developer adds Web Deploy support to the application package. Microsoft Web Deploy provides the framework for deploying the Web applications onto Azure. With Web Deploy, a developer adds a couple of manifest files to the root directory of an existing ZIP package that tell Azure Gallery installer how to deploy the application.

The manifest.XML file tells what is in the package and allows the developer to set the name of the directory and Web site where the package is deployed. The parameters.xml file gives developers the ability to ask the user for information during the install process, such as Web site path. Learn more about how to define the Web Deploy manifest files in the Application Packaging Guide. Also check out Tips and Tricks for a successful submission to Azure Website Gallery.

STEP 4: SUBMIT APPLICATION TO WEB APPLICATION GALLERY

Once the package is built and tested, the Web developer is ready to submit the package to the Web Application Gallery. To learn on how to submit the application, click here .

The Web Application Gallery Submission form in the Web Application Gallery starts by collecting information about the application. See the Submitting Links to the Web Application Gallery walkthrough for a detailed description of how to submit an application. Each application is reviewed to make sure that the application follows the Web Application Gallery Principles. Microsoft may contact the application developer in the course of the review, and also to inform the application developer about the state of the submission.

WEB APPLICATION GALLERY DEVELOPERS

If an application developer is accepted into the Web Application Gallery, the lifecycle of the application continues at the developer’s pace. With each package update, the application developer must contact the Microsoft Web Application Gallery to provide a new SHA1 hash, which helps secure the distribution point.

For general application questions and issues, the Web Application Gallery team redirects the user to the application’s free support forums.

For Installation and Deployment failures on Azure Gallery, please use Azure Websites Support forums to inform us or email us at appgal@microsoft.com.

REQUIREMENTS/CRITERIA CHECKLIST

1. Must meet Web Application Gallery Principles 
2. Application must work with on Azure Websites and IIS (Windows 2003 to 2012 server, Win 7, 8 clients, test application Web PI, Web Matrix)
3. Application must belong to one of the category :
   • Blog
   • CMS
   • Forum
   • Wiki
   • Tools
   • Frameworks
   • Templates
   • eCommerce
   Application must be functional based on the category it belongs to. It must be tested by the partner on Azure websites. App Gallery team will run basic tests on the application before publishing the application in the Azure App Gallery
4. Application must be compatible with Web Matrix:
   • User should be able to edit and download your application with Web Matrix
   • Community or Application partner ,must provide support for Web Application 

https://sunithamk.wordpress.com/2013/09/17/wordpress-with-sql-azure-on-windows-azure-websites/

1. There will be a maximum of 5 applications showcased in the Web App Gallery website

2. The list of applications will include a combination of

• Most popular application in the Gallery
• New applications added to Azure Application Gallery for Windows Azure Websites
• Updates to existing applications added to the Azure Application Gallery for Windows Azure Websites

For more questions , contact appgal@microsoft.com

• Testing Application Packages for the Web Application Gallery – Part 1
• Testing Application Packages for the Web Application Gallery – Part 2

PACKAGING PROCESS

The following procedure is a summary of the most common process for preparing a working application for inclusion in the Windows Azure App Gallery. The steps are described in more detail in the sections that follow.

1. Review the Windows Azure Application Gallery Principles. All applications in the Windows Azure Application Gallery must follow these principles.
2. Create and test a Web Deploy application package
3. Submit the package to the Gallery for testing using the submission form.
4. Resolve any issues with the Application Gallery team.

CREATE A WEB DEPLOYABLE PACKAGE

To create your application package, you need to create the following  files:

1. Manifest.xml: Manifest file says what’s in the application package file and how to install it . Here is a basic manifest file 

<MSDeploy.iisApp> 

  <!-- iisapp will copy the contents of the application root folder , in this case it is  ‘mypythonapp’ to the newly created site for the application --> 

  <iisApp path="mypythonapp"/> 

</MSDeploy.iisApp>

Some of the other things you can do with the manifest file

• Set permissions for files or folder using setAcl provider  
• Run any prerequisite  SQL scripts required for your application using dbfullsql (SQL Server) and dbmysql (MySQL) provider
• Copy files from the root of the ZIP folder to the site root folder when installing the ZIP package using alias provider

 For more details refer Packaging Guidelines Reference Guide

2. Parameters.xml :Parameters file has a list of parameters that accept user input received during installation 

<parameters>

<!--The application path needs to be set here . Leave the defaultValue as empty as this will be replaced with the path to site that will be created during deployment -->

<parameter name="AppPath"  defaultValue="" tags="iisapp">

<parameterEntry type="ProviderPath" scope="iisapp"    match="mypythonapp"  />

</parameter>

</parameters> 

For more details refer Packaging Guidelines Reference Guide

3. Web.config : Create a web.config file  that will be part of your application root folder  that will configure your application to

• route all requests to the specified WSGI handler
• Set Environment variables using appSettings
• If the framework should serve certain files served statically, or from another web framework such as Node.js or ASP.NET, they could match different URLs in the rewrite, or could have additional web.config files masking the rewrite. For more information on URL rewrite , refer this article

<configuration>

    <appSettings> 

        <!-- The appSettings keys will be set as Environment variables --> 

        <!—You need to set the Python Path for the application in web.config . For Azure websites, use ‘D: \home\site\wwwroot’ as this will point to the site root where the any frameworks needed by your application will reside --> 

        <add key="pythonpath" value="D:\home\site\wwwroot" />

        <!-- You need to set the WSGI_HANDLER  for the application in web.config . It's a module/package name, followed by the attribute in the module to be used; for example mypackage.mymodule.handler. Add parentheses to indicate that the attribute should be called. -->

        <!-- Here is an example WSGI_HANDLER for a Django based application  -->

        <add key="WSGI_HANDLER" value="django.core.handlers.wsgi.WSGIHandler()" /> 

<!—If your application requires any additional app settings , then include then in this setting . For example Django require “DJANGO_SETTINGS_MODULE’ app settings, and this should be added in this section as seen below -->

 <!--   <add key=" DJANGO_SETTINGS_MODULE" value="DjangoApplication.settings" /> -->

     </appSettings>

 <system.webServer>

  <handlers> 

<!-- Configure the handler mapping for your application using the path to the Python interpreter and the path to the wfastcgi.py script . This handler mapping will be the same for any Python Application. Make sure your application has an empty ‘handler.fcgi’ file as the requests are mapped to this file -->

        <add name="Python_FastCGI"

                path="handler.fcgi"

                verb="*"

                modules="FastCgiModule"

                scriptProcessor="D:\Python27\python.exe|D:\Python27\Scripts\wfastcgi.py"

                resourceType="Either"

                requireAccess="Script" />

        </handlers> 

<!--  Include this rewrite rule as seen below to rewrite requests and route them through handler.fcgi -->

        <rewrite>

            <rules>

                <rule name="Rewrite Rule" stopProcessing="true">

                    <match url="(.*)" ignoreCase="false" />

                    <conditions>

                        <add input="{REQUEST_FILENAME}" matchType="IsFile" negate="true" />

                    </conditions>

                    <action type="Rewrite" url="handler.fcgi/{R:1}" appendQueryString="false" />

                </rule>

            </rules>

        </rewrite>

    </system.webServer>

</configuration>

4.handler.fcgi :  Include an empty handler.fcgi  is used as an empty handler file under the web site root to serve as the request target .

Refer this article on how to configure Python for Windows Azure

PACKAGE AN APPLICATION

Create a compressed file (Zip) package of the application. You can create the Zip file with Windows® Explorer, WinZip, or the Linux zip command. The Manifest.xml, Parameters.xml go in the root directory of the ZIP package. The rest of your application goes in a sub folder of the root as in the diagram below.

mypythonapp.zip
\
 +--Manifest.xml (required)
 +--Parameters.xml (required)
 +--mypythonapp root folder
    \
     +-- your application’s sub folders and files  

     +-- Python Framework modules, example ‘django’ framework folder will be placed here   
     |--web.config (required)
     |--handler.fcgi (required)

TEST APPLICATION PACKAGE

Install dependencies for testing the application : All you need is Web deploy v3.0

Setup a Windows Azure account if you don’t have one  

If you don’t already have an account for Windows Azure, you can setup a free trial account that is available for 90 days or you can sign up for an Azure subscription based on the plans available. If you already have a Windows Azure account you can use the existing account.

Create a Website for your application using the Azure Management Portal

Login to https://manage.windowsazure.com and create a new site or use an existing site. Click on the site to access its Dashboard. Now download the Publish Profile . Open the file in any text editor. Here is a sample:

<publishProfile profileName="myazuresite - Web Deploy" publishMethod="MSDeploy" publishUrl="waws-prod-001.publish.azurewebsites.windows.net:443" msdeploySite="myazuresite" userName="$myazuresite" userPWD="7nbQc4ngW" destinationAppUrl="https://myazuresite.azurewebsites.net" SQLServerDBConnectionString="" mySQLDBConnectionString=" " hostingProviderForumLink="" controlPanelLink="https://windows.azure.com">

Build a SetParameters File for deploying your application

You can name this file as you would name a filename, but for the sake of this article let’s say the file is called SetParameters.xml .

This is a sample of the SetParameters.xml file. You can see the parameters.xml file from the web deployable package here  .

<parameters> 

 <!--The name of the parameter matches the application path parameter in parameters.xml . Value for the parameter is azure site name  -->

     <setParameter name="AppPath" value="myazuresite" /> 

</parameters>

Run Web Deploy Command Line

Open Command Prompt with elevated privileges and run msdeploy.exe to publish the application to Azure site you just created.

Usage:

Msdeploy.exe –verb:sync –source:package=<pathToLocalZip> -dest:auto,computername=”<publisherURLwithHttpsAndPortOr8172>/msdeploy.axd?site=<remoteSiteName>”,username=<publishingUserName>,password=<publisherPwd>,authtype=basic  - setParamFile:<pathToLocalSetParamFile>

Example:

C:\Program Files\IIS\Microsoft Web Deploy V3>Msdeploy.exe -verb:sync -source:package="c:\packages\mypythonapp.zip" -dest:auto,computername='https://waws-prod-001.publish.azurewebsites.windows.net:443/msdeploy.axd?site=myazuresite',username='$myazuresite',password='7nbQc4ngW',authtype=basic -setParamFile:"c:\setparameters.xml"

Once your application package has been successfully deployed to Azure site. Browse the Site URL and to verify if your application runs successfully on Windows Azure .

REFERENCES

Tips for a successful submission to Windows Azure App Gallery

Packaging Guidelines Reference Guide

Windows Azure Python Developer center

Configuring Python with Windows Azure Web Sites

Step#1 : Review Web App Gallery Principles which are the basic requirements that you need to understand  before submitting an application .

Step#2 : Build a package for your application for Web App Gallery with these guidelines. You need to test the application for App Gallery before submitting . Here are some video tutorials that shows  what the App Gallery team tests for :

• Testing Application Packages for the Web Application Gallery – Part 1
• Testing Application Packages for the Web Application Gallery – Part 2

1. Create a new product <entry> for your  application

<!-- Sample application with dependencies -->
 <entry type="application">
<!-- Enter a UNIQUE productId for your application to avoid conflicts with other existing applications and products in Web PI -->
 <productId>Sample_PHP_MySQL_App</productId>
 <!-- Enter an appropriate title for your application -->
 <title>Sample PHP and and MySQL application</title>
<!-- Include some brief description about the application  -->
 <summary>PHP and MySQL application sample</summary>
 <!-- Include any detailed information about the application -->
 <longSummary>Sample PHP and MySQL to show how to add a feed with a custom PHP application to WebPI and define all dependencies.</longSummary>

 <keywords>
 <!-- To display under PHPApps subtab , include this Keyword --> 
 <keywordId>MyApps</keywordId>
 <keywordId>MySQL</keywordId>
 </keywords>
<version>1.0</version>
 <images>
 <icon>c:\SamplePHPAppIcon.jpg</icon>
 </images>
<updated>2009-10-5T18:30:02Z</updated>
 <published>2009-10-5T18:30:02Z</published>
<author>
 <name>Sample Application Builder</name>
 <uri>https://www.contoso.com</uri>
 </author>
<!-- Related product can be any product that is nice to have  , but is not required -->
 <related>
 <relatedProduct>
 <productId>MySQL</productId>
 </relatedProduct>
 </related>
<!-- 
 Minimum set of requirements/dependencies in order to successfully install the application: 
 PHP, WDeploy, SQL Management Objects, MySql Connector and URL Rewrite.
 You can replace PHP , Wincache to ASP.NET product Ids (ASP.NET 4.5 : NetFramework45  ; ASP.NET 3.5 : NetFramework35 )  if your application is an ASP.NET application . 
 -->
 <dependency>
 <and>
 <dependency>
 <productId>WDeployNoSMO</productId>
 </dependency>
 <dependency>
 <productId>PHP53</productId>
 </dependency>
 <dependency>
 <productId>MySQLConnector</productId>
 </dependency>
 <dependency>
 <productId>UrlRewrite2</productId>
 </dependency>
 </and>
 </dependency>
 <!-- Installer for an application should be Web Deploy package -->
 <installers>
 <installer>
 <id>1</id>
 <!-- List of languages this package is localized in: English, Russian, French, German and Italian -->
 <languageId>en</languageId>
 <languageId>ru</languageId>
 <languageId>fr</languageId>
 <languageId>de</languageId>
 <languageId>it</languageId>
 <installerFile>
 <!-- size of the package in KBs -->
 <fileSize>1024</fileSize>
<!-- Include a local file path like 'file://c:\myapplication\myapp.zip' or a HTTP URL -->
 <installerURL>https://www.contoso.com/SamplePHPApplication.zip</installerURL>
 <!-- SHA of the package file for signature verification -->
 <sha1>1223334444555556666667777777888888889999</sha1>
 </installerFile>
 <helpLink>https://www.contoso.com/SamplePHPApplicationForum.aspx</helpLink>
 <msDeploy>
 <!-- Default page is a start page -->
 <startPage />
 </msDeploy>
 </installer>
 </installers>
 </entry>

2. Create a new Tab where the application you wish to test can be listed

<tabs>
 <tab>
 <keywordTab>
 <!-- Creates a new Tab called Sample Applications -->
 <id>SampleApplications</id>
 <name>Sample Applications</name>
  <description>Select from sample applications:</description> 
   <!-- Create multiple sub-tabs under 'Sample Applications'  -->
    <keywords> 
      <keywordId>MyApps</keywordId>
    </keywords>
  </keywordTab>
 </tab>
 </tabs>

3. Create a new Keyword to categorize the application . This allows you to creates Groups of applications within the same Tab section

<keywords> 
<keyword id="PHPApps">PHP Apps</keyword>
</keywords>

You can modify this  feed as per your needs  and test your application with Web Platform installer .

#1 : manifest.xml (required): 

This file is used to

• set up the ACLs for your application
• content path for your application
• may include any references to SQL Server or MySQL scripts
• may include “alias” provider that allows you to “add”  a new file to the code base during deployment or “rename” an existing file during deployment 

#2: parameters.xml (required):

This file is used to identify the

• Destination content path for your application
• ACL parameters that match the ACL specified in the manifest.xml 
• Database parameters if application supports a database
• Any user defined parameters that allows you to replace “information” in a file based on user input or replace “information” with some default value that would be required for a specific scenario.

For example, you can use parameters to create a site’s admin user or allow the user to enter a Secret Key for the ecommerce application etc.   

#3: SQL Server or MySQL scripts (required if application supports a database):

The minimum requirement for these scripts is to create a ‘non-admin’ database user. You can find sample scripts here

#4: Application content root folder

This will contain the content of the application that needs to be deployed to a  website

#5: Additional files that are used with “alias” provider in manifest.xml:   

Here is an example of a scenario when this is applicable 

If you have a PHP application say Moodle, and the core package on the community website does not have a web.config file for the application. But we need the web.config file for deploying it to Azure. In this case, you can use the “alias” provider as shown here and include “web.config” file at the root level of the ZIP package

<alias to=”application_root_folder_name/web.config” from=”web.config” />

During deployment, web deploy will copy the web.config from the root level of the zip file to the site root of the application

#1 : What folder and files require Modify Permissions

The default ACL is ReadandExecute for any folder and file. So include ACLs if there is a folder(s) or files that require MODIFY permissions.

For ASPNET applications DO NOT use setAclUser attribute. The default is always Worker Process

Example code in manifest file

<setAcl     path="application/App_Data"    setAclAccess="Modify" />

For PHP applications , alywasy use setAclUser="anonymousAuthenticationUser"

Example code in manifest file

<setAcl     path="application/sites/default/settings.php"     setAclResourceType="File" setAclAccess="Modify"     setAclUser="anonymousAuthenticationUser" /> 

Note # you will NEED to create matching parameters for these ACLs in the parameters.xml file. Web deploy understands which content ACLs need to be changes by referencing both the parameter for setAcl provider and the corresponding match in manifest.xml

#2: Does the application support a database (SQL Server and MySQL).

If yes , then you would have to include SQL Scripts:

For SQL Server/SQL Azure  : 

• One script is required to create a user login
• One script is required for setting permissions for this newly created user

These tasks can be combined in one SQL script, but will not work if you want your application to be included for Azure App Gallery but will work for Web PI and Web Matrix 

For MySQL :

•  Single script required to create the user and setting the permissions for this newly created user

Sometimes you may need to include the database schema scripts in the package if you want the database to be configured during deployment . For more details on creating a package that supports a database , refer to this article

#3: Where is the database information stored in the application

Identify the file where this information is stored and parameterize this database information: database name, host, username , password

For PHP apps , it is usually a configuration setting in the its config file . For example here is a code snippet for parameterizing Database Name

<parametername="Database Name"description="Name of the database for your application."defaultValue="app_db"tags="MySQL,dbName">     <parameterEntrytype="TextFile"scope="install.sql"match="PlaceHolderForDbName"/></parameter><parametername="Automatic Database Name PHP File"defaultValue="define('DB_NAME', '{Database   Name}');"tags="Hidden, MySQL">       <parameterEntrykind="TextFile"scope="wp-config\.php$"match="define\('DB_NAME', '[^']*'\);"/></parameter>

For ASPNET apps , usually is it a connection string format for example

<parameter name="Connection String For Config" defaultValue="Data Source= {DbServer};Database={DbName};uid={DbAdmin};Pwd={DbAdminPW};" tags="Hidden,SQL">
<parameterEntry type="XmlFile" scope="\\web\.config$" match="//connectionStrings/add/@connectionString" />
</parameter>

Note # always use XPATH (if using XmlFile as Type) or Regular expression (if using TextFile as Type) that is generic and will always find a match for the parameter in the configuration file. This is specific to Web Matrix, where the end –user can change the values of the database name or username. Web Matrix should be able to identify the database and allow the user to access the database within Web Matrix

#4: Does this application require additional information from the user

The application may require additional information from the user. If this information needs to be requested from the end-user before deployment, then create parameters to capture this information. If this is handled with the applications “configuration scripts” or “installer”, then you don’t need to create parameters as this will be handled after a successfully deployment.

#5: Does you application satisfy the security standards for App Gallery  

For ASPNET apps, make sure it meets the standard best practices for Security and supports Medium Trust level . For PHP apps, make sure there are Rewrite URLs included in a web.config for the application which can be imported from the application's  htaccess files  . 

Additional references

You can find more articles and samples on Web Application Gallery here .

Once you are logged into the Management portal , you will need to create a new site “from gallery” as shown below

Choose templates category and then select Node JS starter site

Enter the site name , say ‘nodejssite’ and that’s it . Your NodeJS website is ready to be deployed .

Once the Node JS website has been successfully deployed ,  you can click on Web Matrix button to access the site’s content

Browse your newly created Node JS website on windows azure

 If you want to create a Node JS website from scratch you can use the Node JS Empty template or if you want create a website with Node JS Express framework then use  Node JS Express site template  . They can be easily customized to your needs . Have fun building your website with Node JS on Azure .