The python documentation for modwsgi seems to fit what you are asking for. The following webpage has a really simple example and the necessary configuration for a python3-apache2 setup.

http://modwsgi.readthedocs.io/en/develop/user-guides/quick-configuration-guide.html

You will need to install the mod_wsgi for the configuration to work. Take note of the different "_" underscore and "-" dash character used in apt and pip3.

$ sudo apt install apache2-dev libapache2-mod-wsgi-py3
$ sudo pip3 install mod_wsgi

libapache2-mod-wsgi-py3 and mod_wsgi seems to be the same thing. However, my test deployment only works after installing mod_wsgi. Could be configuration issue. The following are the details of the configuration I have tested on Ubuntu 16.04.2.

Application file /home/user/wsgi_sample/hello.wsgi:

def application(environ, start_response):
    status = '200 OK'
    output = b'Hello World!'
    response_headers = [('Content-type', 'text/plain'),
                    ('Content-Length', str(len(output)))]
    start_response(status, response_headers)
    return [output]

Apache2 configuration /etc/apache2/sites-available/000-test.conf

<VirtualHost *:80>
  ServerName testmachine
  <Directory /home/user/wsgi_sample>
    Order allow,deny
    Allow from all
    Require all granted
  </Directory>
  WSGIScriptAlias /hello /home/user/wsgi_sample/hello.wsgi
</VirtualHost>

Enable the site in apache2.

sudo a2ensite 000-test.conf

Open your browser to testmachine/hello.

wsgi may also be deployed on Apache2 using passenger. It demands a slighter longer configuration. Ask a new question if passenger/python3 is desired.

I think you have installed mod_wsgi for python2 with this command:

sudo apt-get install libapache2-mod-wsgi

But if you want to use mod_wsgi with python3, you should install correct mod_wsgi with this command:

sudo apt-get install libapache2-mod-wsgi-py3

Django 1.6+ and mod_wsgi 3.4+ are required to use Python 3 with Apache. For more detail refer to scot's answer.

The first line of httpd.conf: AddHandler cgi-script .cgi .pl is irrelevant, since you're testing python scripts and not perl scripts. And you should define those directives within the location of your python script, and tell apache that it should execute cgi scripts in that location: Options +ExecCGI. This snippet would be a start:

<Directory /path/to/sample.py />
  Options +ExecCGI
  AddHandler cgi-script .py
</Directory>

Addendum 1:

As per my last comment, try this script. It should spit information about the cgi environment.

#!/usr/bin/python
import cgi
cgi.test()

Addendum 2:

I got your script to work with the above configuration. The problem is that script is written in python2. And the default interpreter apache is invoking to execute the script, is python3 (at least in my case, and chances are this would be the same for you too).

This is a python3 version of the hello world script:

#!/usr/bin/env python

# enable debugging
import cgitb
cgitb.enable()

print("Content-Type: text/plain;charset=utf-8")
print()

print("Hello World!")

Addendum 3:

For the first error, make sure the permission and the ownership of whatever directory and files you're attempting to deploy are properly set. And try adding those directives to httpd.conf:

Order allow,deny
Allow from all

Which will get you this:

<Directory /path/to/sample.py />
  Options +ExecCGI
  AddHandler cgi-script .py
  Order allow,deny
  Allow from all
</Directory>

For the second error, unless I am missing something, it looks like apache is invoking python 3 interpreter to execute your script. To rule out this possibility, you might try the following:

ls -al /usr/bin/python*

This will list the python interpreters available on your system. If you have more than one interpreter you'll get something similar to this output:

/usr/bin/python -> python3*
/usr/bin/python2.6*  
/usr/bin/python3*  

If not, it would be this output:

/usr/bin/python -> python2.6*
/usr/bin/python2.6*  

To make sure, this is not the issue you're having, try with this modified sample script:

#!/usr/bin/python2.6

# enable debugging
import cgitb
cgitb.enable()

print "Content-Type: text/plain\r\n\r\n"
print

print "Hello World!"

You'll notice that I explicitly mentioned the version of the interpreter apache should invoke, which is ugly. But for the sake of testing, you can do it. Of course you should map #!/usr/bin/python2.6, to whatever binary you have on your server, and make sure you don't mix python 3 comtipable code with python 2 interpreter and vice versa.

You can't force mod_wsgi compiled for one Python version to use a different Python installation for a different version. This is because mod_wsgi actually links the Python library for the version it was compiled for, it doesn't just run the python program of some arbitrary version.

The only thing you can do is uninstall mod_wsgi from system packages (which uses Python 3.5) and install mod_wsgi from source code yourself and compile it against Python 3.6.

Also, neither of the paths you gave WSGIPythonHome and WSGIPythonPath were correct anyway. When you install mod_wsgi from source code, don't set those directives as they will continue to screw things up.

mod_python is basically non-maintained - you should look into mod_wsgi. Install the package libapache2-mod-wsgi, then issue sudo a2enmod wsgi to enable it.

Just as a quick example to get it running, stuff something like this in your /etc/apache2/sites-enabled/default:

WSGIScriptAlias /test /path/to/python/file.py

And in the file /path/to/python/file.py:

def application(environ, start_response):
    start_response('200 OK', [('Content-Type', 'text/plain')])
    return "Hello World"

After re-starting Apache2, any request to /test will turn into a call of application() in your python file.

For further reading, look into WSGI (WebServer Gateway Interface), the way Python integrates with web-servers.

Bonus / Update:

Python (unsurprisingly) has a small WSGI server in the standard library for testing. If you add this in the bottom of your file, you can run it as any old executable for testing purposes, and then let Apache take over for production:

if __name__ == '__main__':
    from wsgiref.simple_server import make_server

    httpd = make_server('', 8080, application)
    print "Serving on http://localhost:8080"

    httpd.serve_forever()

Install wsgi

On Ubuntu 22.04 with Python 3, you have to install libapache2-mod-wsgi-py3:

sudo apt install libapache2-mod-wsgi-py3
sudo a2enmod wsgi
sudo service apache2 restart

Configure your vhost

Your manual mentions creating a new vhost config /etc/apache2/conf-available/wsgi.conf. However, this is not required and if you don't have other sites on the server, you can use the default Apache config: /etc/apache2/conf-available/000-default.conf. Add the following line before the line:

WSGIScriptAlias ​​/wsgi /var/www/html/wsgy.py

Don't forget to restart the Apache server:

sudo service apache2 restart

Create Python script

To configure mod_wsgi, you have to create a Python script that will be served by the Apache web server: sudo nano /var/www/html/wsgi.py. The example wsgi.py in your manual is returning error 500, so you can use this code instead:

def application(environ, start_response):
    status = '200 OK'
    output = b'Hello World!\n'
    response_headers = [('Content-type', 'text/plain'), ('Content-Length', str(len(output)))]
    start_response(status, response_headers)
    return [output]

Accessing the Python site

• To access the Python file, you should use http://your-server-ip/wsgi or whatever alias you configured in your vhost's file.

• Opening http://your-server-ip/wsgi.py will still return Python code instead of execute it.

While there are several was to do it such as apache CGI (this method), mod_python or mod_wsgi, of which neither take very long to setup. I found this method to have the least steps.

First step to enable cgi mod (a2enmod in my case was not in my default path, but was found in /usr/sbin/)

/usr/sbin/a2enmod cgi

systemctl restart apache2

That is it !! now if you put a .sh or .py script in /usr/lib/cgi-bin folder and make it owner root and execute permission it can be accessed from the web address

http://machine_address/cgi-bin/script.py

note that you need to have your shebang at the start of your script

#!/usr/bin/python3
print("Content-Type: text/html;charset=utf-8")
print ("Content-type:text/html\r\n")
print("<H1> Hello, From python server :) </H1>")

Going Further:

• You can keep the script somewhere more convenient for editing such as your home dir or a repo, and simlink it to /usr/lib/cgi-bin, just chown the group to your user group while keeping the owner root, and set perms to 775

• You can access the submitted query url for GET params with: (after import os)

  queryString = os.environ.get('QUERY_STRING')
  

• Even though the cgi script must be owned by root to run, inside the python script any code is run as user www-data (default apache user). This might be fine, but if you need it as a different user, such as your 'normal' user account, one option (which i looked into) is mod_suexec which allows specifying the user a cgi script runs as. But I found it easier to just change the default user that apache runs as to my main user account. Its quicker/simpler and then I can access the error log files without su to root (to see python errors), and interact with my home files. Set user/grp in:(followed by restart)

  /etc/apache2/envvars
  

• You can customise settings more look in eg cgi path, symlink perms etc.

   /etc/apache2/conf-enabled/serve-cgi-bin.conf
  

• You can have python output errors in pretty html on your page, rather than to apache error.log by adding this to the top of your script:

  import cgitb
  cgitb.enable()