Python для windows server 2012

Answers

• You’re still going to need c:python27 in your PATH. PYTHONPATH is used to find modules/imports — not to tell Windows where to find the executable.

  ---

  G. Samuel Hays

  • Marked as answer by

    Monday, April 29, 2013 4:01 PM

1. Installed Python
2. Installed IIS with CGI
3. Created and activated a Python virtual environment
4. Installed Django and wfastcgi in a Python virtual environment
5. Created a new Django project
6. Ran the Django project using the Django development server

With all the underlying infrastructure in place, the last step is to configure IIS to serve Django applications. The Django development server is not designed for production use, so using a production-quality web server such as IIS is mandatory for production applications.

1. Open the IIS Manager by clicking the Windows button, clicking on Administrative Tools, and double-clicking Internet Information Services (IIS) Manager
2. Click on the name of the server in the list on the left. If you see the following dialog box, check the box “Do not show this message” and click “No.” (You can always get to this later if necessary by clicking “Get New Web Platform Components” under “Actions” on the right-hand side of IIS Manager.)
   
3. Double-click the “FastCGI Settings” icon
   
4. Under “Actions” on the right-hand side click “Add application …”
5. In the Add FastCGI Application dialog, in the “Full Path” box, type the path to the Python executable for the application’s virtual environment:
   C:virtualenvsfooScriptspython.exe
6. In the Arguments input box, type the path to the wfastcgi.py file in the application’s virtual environment:
   C:virtualenvsfooLibsite-packageswfastcgi.py
7. At this point your settings in the Add FastCGI Application dialog should look like this:
   
8. With the Add FastCGI Application dialog box still open, under the “General” section, click on the “Environment Variables” line, then click the gray “…” button that appears next to (Collection) on the right-hand side of the line. This opens the EnvironmentVariables Collection Editor dialog.
   
9. In the EnvironmentVariables Collection Editor dialog, click “Add”
10. In the “Name properties” section on the right, click the input box to the right of “Name,” remove the “Name” text that is already in the input box, and enter DJANGO_SETTINGS_MODULE (note that this MUST be entered in ALL CAPS)
11. Click the input box to the right of “Value” and enter foo.settings
12. Click “Add” again and enter the following:
    Name: PYTHONPATH
    Value: C:appsfoo
13. Click “Add” again and enter the following:
    Name: WSGI_HANDLER
    Value: django.core.wsgi.get_wsgi_application()
14. At this point you will have three environment variables:
    
1. NOTE: All of these settings are CASE-SENSITIVE. They must be entered with exactly the case indicated here in order to work.
15. Click “OK” to close the EnviromentVariables Collection Editor
16. Click “OK” to close the Add FastCGI Application dialog

Create and Configure a New IIS Web Site

1. Open IIS Manager
2. On the left-hand side under Connections, expand the tree under the server name by clicking on the arrow to the left of the server name
3. Right-click on the Sites folder and click “Add Website …”
4. For the site name enter foo
5. For the physical path, type the following:
   C:appsfoo
6. For the purposes of this example configuration, change the Port to 81, since the Default site is running on port 80. For a real-world application you’ll likely want to use name-based virtual hosting by adding bindings and run the site on port 80.
7. You may leave the “Host name” blank. At this point the Add Website dialog should look like this:
   
8. Click “OK”

Next, we’ll add a FastCGI handler mapping to this site so the requests coming into the site will be processed by the Django application.

1. In IIS Manager, expand the Sites folder on the left-hand side and click on the foo site
2. On the right, double-click “Handler Mappings”
   
3. On the right, under “Actions,” click “Add Module Mapping”
   
4. In the “Request path” box enter an asterisk: *
5. Click the arrow on the right-hand side of the “Module” box and select “FastCgi Module”
1. NOTE: Make sure to select FastCgi Module, NOT CgiModule
6. In the “Executable” box, enter the following:
   C:virtualenvsfooScriptspython.exe|C:virtualenvsfooLibsite-packageswfastcgi.py
1. Note that the character after python.exe is a pipe (|), which is entered by pressing Shift- on your keyboard
7. In the “Name” box, enter Django Handler (you can call this whatever you want; it’s merely a friendly name for the module mapping)
8. The Add Module Mapping dialog should now look like this:
   
9. Click the “Request Restrictions” button and uncheck the “Invoke handler only if request is mapped to:” checkbox
10. Click “OK” to close the Request Restrictions dialog
11. Click “OK” to close the Add Module Mapping dialog
12. When prompted “Do you want to create a FastCGI application for this executable?” click “No” since we created the application earlier.
1. Note that you CAN have it create the FastCGI application for you from the module mapping, but the settings seem to be different and the end result isn’t fully editable. I also detailed how to create the FastCGI application to be as thorough as possible with all the various pieces involved.
13. You will now see the Django Handler listed in the Handler Mappings for the foo website:
    

At this point everything should be working, so verify by loading the application in a browser.

1. Open a browser on the server
2. Browse to http://localhost:81
3. You should see the following:
   

This is the same result as when we ran the Django test server earlier, but now the requests are being handled by IIS.

1. Using a plain text editor such as Notepad, or Idle if that was installed when you installed Python, open the file C:appsfoofoosettings.py
2. Scroll to the bottom of the file, or use the find feature of your text editor, and find the STATIC_URL setting
3. Above the STATIC_URL setting, add the following setting:
   STATIC_ROOT = os.path.abspath(os.path.join(BASE_DIR, ‘foo’, ‘static’))
1. The placement of the STATIC_ROOT setting in the settings.py file doesn’t matter, but putting it right next to the STATIC_URL setting is typical and keeps all the settings related to static files in one place.
2. The STATIC_ROOT setting we’re using as our example will put the static files in C:appsfoofoostatic
4. Save the settings.py file

Run the collectstatic Management Command

1. Don’t include the directory to which the STATIC_ROOT setting is pointing in your application’s code repository; these files should not be tracked and versioned from that location, and the Django development server handles static files for you by serving them directly from their various locations. The collectstatic management command should be run as a normal part of the deployment process for production instances of your application.
2. For complete information about Django’s handling of static files, and production deployment of static files, please refer to the following section of the Django documentation:
1. https://docs.djangoproject.com/en/1.9/howto/static-files/
2. https://docs.djangoproject.com/en/1.9/howto/static-files/deployment/

At this point your Django application should be playing nicely with IIS.

Additional Information

• http://mrtn.me/blog/2012/06/27/running-django-under-windows-with-iis-using-fcgi/
• https://www.toptal.com/django/installing-django-on-iis-a-step-by-step-tutorial
• https://www.youtube.com/watch?v=kXbfHtAvubc
• https://www.youtube.com/watch?v=cgTFrAwXeoI
• http://kiahosseini.github.io/server/2016/01/05/running-multiple-django-python-3-projects-in-windows-server-2012-on-iis.html
• http://www.wahyu.org/running-django-1-8-1-on-iis-7-with-python-2-7-9/
• http://serverfault.com/questions/366348/how-to-set-up-django-with-iis-8
• http://stackoverflow.com/questions/34840354/django-on-iis-django-core-exceptions-appregistrynotready-apps-arent-loaded-ye (where I discovered that most of the examples of running Django on IIS had an older reference to the WSGI handler)
• http://netdot.co/2015/03/09/flask-on-iis/
• https://pypi.python.org/pypi/wfastcgi
• https://pip.pypa.io/en/latest/user_guide/#installing-from-local-packages (good information about how to package up applications for deployment on an server without internet access)
• https://groups.google.com/forum/#!topic/web2py/0jUZmhWjaxY
• https://heejune.me/2015/04/22/running-python-flask-on-a-local-iis-not-azure-with-wfastcgi-py/
• http://www.pyinstaller.org/ (another option for packaging up Django applications for automated deployment)
• http://stackoverflow.com/questions/32312590/how-to-fetch-static-css-files-with-django-on-iis

Additional Avenues of Exploration

• It is possible to use a web.config file at the web site level instead of the GUI IIS configuration for FastCGI and the site-specific handlers; see http://stackoverflow.com/questions/9794985/iis-this-configuration-section-cannot-be-used-at-this-path-configuration-lock for details about what needs to be enabled to support this. While it’d be handy to include these as part of the application’s codebase, it does involve installing and enabling a bunch of additional IIS add-ons at the root level of IIS, none of which are necessary for the purposes of running a Django app.

Install WFastCGI Gateway for IIS and Python 3.4

1. Open IIS Manager
2. Click on the server in the list under “Connections” on the left-hand side
3. At this point you may see a dialog box prompting you to install Microsoft Web Platform:
   
1. If you see this dialog box, click “Yes.” This will open the download page in a web browser.
2. If you do not see this box, under “Actions” on the right-hand side of IIS Manager, click on “Get New Web Platform Components.” This will open the download page in a web browser.
3. You will be prompted to launch the Microsoft Web Platform application every time you launch IIS Manager, so if you see this dialog box after you have already installed the Web Platform Installer, feel free to check “Do not show this message” and then click “No.”
4. On the Microsoft Web Platform web page, click the “Free Download” button.
5. After the download completes, located the downloaded file and double-click to run it. As of the time of this writing the file is called wpilauncher.exe
6. If you see a Security Warning dialog, click “Run” to run the installer.
7. After the installation completes, the Web Platform Installer 5.0 application will launch.
8. In the Web Platform Installer 5.0 application, in the search box on the top right, type “fastcgi” (without the quotes) and press Enter.
9. In the search results, locate “WFastCGI 2.1 Gateway for IIS and Python 3.4” and click the “Add” button.
   
10. At the bottom of the Web Platform Installer application, click “Install.”
11. In the Prerequisites dialog that appears, click “I Accept” to accept the terms of the license.
12. The WFastCGI extension will be downloaded and installed. When the installation completes, click “Finish” to close the installation dialog, and then click “Exit” to close the Web Platform Installer.

Note that doing installing the WFastCGI Gateway and Python 3.4 in this way does not automatically configure the FastCGI and Handler Mappings in IIS for you. It does install a default Python FastCGI application, but this will not necessarily automatically work with your application, and at a minimum you would still need to add a Handler Mapping for your application.

Posted by4 years ago

Archived

My wife and I are trying to get Python (latest 3.x) working on our Windows Server 2012 R2. we have Python installed and we can see it in the command prompt. but we are stuck on configuring the web.config file . is there a step by step instruction on setting up python on Windows Server? the MS website is not intuitive.

any guidance is greatly appreciated.

level 1

what exactly are you trying to do? you mentioned web.config which suggests you’re trying to integrate Python with IIS