nginx/unit
GitHub: nginx/unit
Stars: 5558 | Forks: 369
# NGINX Unit
[](https://www.repostatus.org/#unsupported)
## Note: This repository has been archived. There will likely be no further development at this repo, and security vulnerabilities may be unaddressed.
## The repo may be cloned and used under its current license.
## Universal Web App Server
NGINX Unit is a lightweight and versatile open-source server that has
two primary capabilities:
- serves static media assets,
- runs application code in eight languages.
Unit compresses several layers of the modern application stack into a potent,
coherent solution with a focus on performance, low latency, and scalability. It
is intended as a universal building block for any web architecture, regardless
of its complexity, from enterprise-scale deployments to your pet's homepage.
Its native [RESTful JSON API](#openapi-specification) enables dynamic
updates with zero interruptions and flexible configuration, while its
out-of-the-box productivity reliably scales to production-grade workloads. We
achieve that with a complex, asynchronous, multithreading architecture
comprising multiple processes to ensure security and robustness while getting
the most out of today's computing platforms.
## Installation
### macOS
Run the following command to install both `unitd` (the Unit daemon) and
`unitctl` (the control tool).
$ brew install nginx/unit/unit
For details and available language packages, see the
[docs](https://unit.nginx.org/installation/#homebrew).
### Docker
$ docker pull unit:
$ mkdir /tmp/unit-control # customize as needed.
$ docker run -d \
--mount type=bind,src=/tmp/unit-control,dst=/var/run \
--mount type=bind,src=.,dst=/www \
--network host \
unit
For a description of image tags, see the
[docs](https://unit.nginx.org/installation/#docker-images).
Your current working directory will now be mounted to the Unit image at `/www`.
You can reach its socket at `/tmp/unit-control/control.unit.sock` assuming no
further customizations have been made.
### Debian, Ubuntu, Amazon Linux, Fedora, Red Hat
This helper script configures the correct package repositories for system.
$ wget https://raw.githubusercontent.com/nginx/unit/master/tools/setup-unit && chmod +x setup-unit
# ./setup-unit repo-config
Debian derivatives:
# apt install unit
Fedora derivatives:
# yum install unit
For details and available language packages, see the
[docs](https://unit.nginx.org/installation/#official-packages).
## Getting Started with `unitctl`
[`unitctl`](tools/README.md) streamlines the management of NGINX Unit processes
through an easy-to-use command line interface. To get started with `unitctl`,
download it from the
[official GitHub releases](https://github.com/nginx/unit/releases)
or [Homebrew](#macos).
### Installation
Download the appropriate `unitctl` binary for your system from the
[NGINX Unit releases](https://github.com/nginx/unit/releases/).
$ tar xzvf unitctl-master-x86_64-unknown-linux-gnu.tar.gz
# mv unitctl /usr/local/bin/
## Launch Unit using Docker
If you have [Docker installed](https://docs.docker.com/engine/install/) on
your machine, and then you can effortlessly spin up one of
[Unit's official Docker images](https://hub.docker.com/_/unit)
alongside your application.
Here's an example using the `unit:python` Docker image:
$ unitctl instances new 127.0.0.1:8001 /path/to/app 'unit:python'
`/path/to/app` will mount to `/www` in the Docker filesystem.
Save this to `/path/to/app/wsgi.py`:
def application(environ, start_response):
start_response("200 OK", [("Content-Type", "text/plain")])
return (b"Hello, Python on Unit!")
You can then interactively edit the currently active configuration:
$ unitctl edit
{
"listeners": {
"*:8000": {
// Point listener to new application
"pass": "applications/python"
}
},
// Add an application definition
"applications": {
"python": {
"type": "python",
"path": "/www/",
"module": "wsgi"
}
}
}
Valid configurations will be applied upon save and close.
$ curl localhost:8000
Hello, Python on Unit!
More Python configuration examples can be found in the
[Unit docs](https://unit.nginx.org/howto/samples/#python).
## Hello World with PHP and curl
Unit runs apps in a
[variety of languages](https://unit.nginx.org/howto/samples/).
Let's explore the configuration of a simple PHP app on Unit with `curl`.
Suppose you saved a PHP script as `/www/helloworld/index.php`:
To run it on Unit with the `unit-php` module installed, first set up an
application object. Let's store our first config snippet in a file called
`config.json`:
{
"helloworld": {
"type": "php",
"root": "/www/helloworld/"
}
}
Saving it as a file isn't necessary, but can come in handy with larger objects.
Now, `PUT` it into the `/config/applications` section of Unit's control API,
usually available by default via a Unix domain socket:
# curl -X PUT --data-binary @config.json --unix-socket \
/path/to/control.unit.sock http://localhost/config/applications
{
"success": "Reconfiguration done."
}
Next, reference the app from a listener object in the `/config/listeners`
section of the API. This time, we pass the config snippet straight from the
command line:
# curl -X PUT -d '{"127.0.0.1:8080": {"pass": "applications/helloworld"}}' \
--unix-socket /path/to/control.unit.sock http://localhost/config/listeners
{
"success": "Reconfiguration done."
}
Now Unit accepts requests at the specified IP and port, passing them to the
application process. Your app works!
$ curl 127.0.0.1:8080
Hello, PHP on Unit!
Finally, query the entire `/config` section of the control API:
# curl --unix-socket /path/to/control.unit.sock http://localhost/config/
Unit's output should contain both snippets, neatly organized:
{
"listeners": {
"127.0.0.1:8080": {
"pass": "applications/helloworld"
}
},
"applications": {
"helloworld": {
"type": "php",
"root": "/www/helloworld/"
}
}
}
## WebAssembly
Unit supports running WebAssembly Components (WASI 0.2).
For more information see the
[Unit Configuration Docs](https://unit.nginx.org/configuration/#configuration-wasm).
## OpenAPI Specification
Our [OpenAPI specification](docs/unit-openapi.yaml) aims to simplify
configuring and integrating NGINX Unit deployments and provide an authoritative
source of knowledge about the control API.
标签：客户端加密