Installation

You can install Angie by:

• Setting up our binary repo

• Downloading a Docker image (OSS only)

• Building it from source (OSS only)

Binary Packages

To install and update Angie using your distro’s package manager, add and set up the Angie package repository.

Supported Distributions

Distro	Versions	Architectures
AlmaLinux	9,   8	x86-64, arm64
Alpine	3.19,   3.18,   3.17,   3.16	x86-64, arm64
ALT	10 8	x86-64, arm64 x86-64
Astra SE	4.7 1.7	arm64 x86-64
CentOS	9,   8,   7	x86-64, arm64
Debian	12,   11,   10	x86-64, arm64
FreeBSD	14,   13	x86-64, arm64
openSUSE	15	x86-64, arm64
Oracle Linux	9,   8	x86-64, arm64
RED OS	8 7	x86-64 x86-64, arm64
Rocky Linux	9,   8	x86-64, arm64
ROSA	Chrome 12 Fresh 12	x86-64, arm64 x86-64
Ubuntu	22.04,   20.04	x86-64, arm64

Alma, CentOS, Oracle, RED OS, Rocky, ROSA

1. To add the repo, create a file named /etc/yum.repos.d/nginx.repo with the following contents:

   AlmaCentOSOracleRED OSRockyROSA ChromeROSA Fresh

   [angie]
   name=Angie repo
   baseurl=https://download.angie.software/angie/almalinux/$releasever/
   gpgcheck=1
   enabled=1
   gpgkey=https://angie.software/keys/angie-signing.gpg.asc
   

2. Install the Angie package:

   $ sudo yum install -y angie
   

3. (Optional) Install the dynamic module packages you need:

   $ sudo yum install -y <PACKAGE NAME>
   

4. Start the service:

   $ sudo systemctl start angie
   

5. To autostart Angie after server reboot:

   $ sudo systemctl enable angie
   

Alpine

1. Install the prerequisites for adding the Angie repo:

   $ sudo apk update
   $ sudo apk add curl ca-certificates
   

2. Download the public key of the Angie repo for package verification:

   $ sudo curl -o /etc/apk/keys/angie-signing.rsa \
               https://angie.software/keys/angie-signing.rsa
   

3. Add the Angie repo:

   $ echo "https://download.angie.software/angie/alpine/v$(egrep -o \
          '[0-9]+\.[0-9]+' /etc/alpine-release)/main" \
          | sudo tee -a /etc/apk/repositories > /dev/null
   

4. Update the repo indexes:

   $ sudo apk update
   

5. Install the Angie package:

   $ sudo apk add angie
   

6. (Optional) Install the dynamic module packages you need:

   $ sudo apk add <PACKAGE NAME>
   

7. Start the service:

   $ sudo service angie start
   

8. To autostart Angie on server reboot:

   $ sudo rc-update add angie
   

ALT Linux

1. Create the /etc/ssl/angie directory:

   $ sudo mkdir -p /etc/ssl/angie/
   

2. Install the prerequisites for adding the Angie repo:

   $ sudo apt-get update
   $ sudo apt-get install -y curl apt-https
   

3. Download the public key of the Angie repo for package verification:

   $ sudo curl -o /etc/ssl/angie/angie-signing.gpg \
         https://angie.software/keys/angie-signing.gpg
   

4. Import the downloaded key into the trusted key ring:

   $ sudo gpg --no-default-keyring \
         --keyring /usr/lib/alt-gpgkeys/pubring.gpg --import /etc/ssl/angie/angie-signing.gpg
   

5. Save the key’s signature:

   $ echo 'simple-key "angie" {
             Fingerprint "EB8EAF3D4EF1B1ECF34865A2617AB978CB849A76";
             Name "Angie (Signing Key) <devops@tech.wbsrv.ru>";
     }' | sudo tee /etc/apt/vendors.list.d/angie.list > /dev/null
   

6. Add the Angie repo:

   ALT 10ALT 10 SPАLT 8 SP

   $ echo "rpm [angie] https://download.angie.software/angie/altlinux/10/ $(uname -m) main" \
       | sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
   

7. Update the repo indexes:

   $ sudo apt-get update
   

8. Install the Angie package:

   $ sudo apt-get install -y angie
   

9. (Optional) Install the dynamic module packages you need:

   $ sudo apt-get install -y <PACKAGE NAME>
   

10. Start the service:

    $ sudo systemctl start angie
    

11. To autostart Angie on server reboot:

    $ sudo systemctl enable angie
    

Astra SE

1. Install the prerequisites for adding the Angie repo:

   $ sudo apt-get update
   $ sudo apt-get install -y ca-certificates curl lsb-release
   

2. Download the public key of the Angie repo for package verification:

   $ sudo curl -o /etc/apt/trusted.gpg.d/angie-signing.gpg \
               https://angie.software/keys/angie-signing.gpg
   

3. Add the Angie repo:

   $ echo "deb https://download.angie.software/angie/astra-se/$(egrep -o \
          '[0-9]+.[0-9]+' /etc/astra_version) unstable main" \
          | sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
   

4. Update the repo indexes:

   $ sudo apt-get update
   

5. (Optional) When running a Closed Software Environment (CSE), install the key package for Angie binary verification:

   $ sudo apt-get install -y angie-digsig-key
   

   Update the CSE:

   $ sudo update-initramfs -uk all
   

   Then restart the server:

   $ sudo shutdown -r now
   

6. Install the Angie package:

   $ sudo apt-get install -y angie
   

7. (Optional) Install the dynamic module packages you need:

   $ sudo apt-get install -y <PACKAGE NAME>
   

Debian, Ubuntu

1. Install the prerequisites for adding the Angie repo:

   $ sudo apt-get update
   $ sudo apt-get install -y ca-certificates curl lsb-release
   

2. Download the public key of the Angie repo for package verification:

   $ sudo curl -o /etc/apt/trusted.gpg.d/angie-signing.gpg \
               https://angie.software/keys/angie-signing.gpg
   

3. Add the Angie repo:

   DebianUbuntu

   $ echo "deb https://download.angie.software/angie/debian/ `lsb_release -cs` main" \
          | sudo tee /etc/apt/sources.list.d/angie.list > /dev/null
   

4. Update the repo indexes:

   $ sudo apt-get update
   

5. Install the Angie package:

   $ sudo apt-get install -y angie
   

6. (Optional) Install the dynamic module packages you need:

   $ sudo apt-get install -y <PACKAGE NAME>
   

FreeBSD

1. To add the Angie repo, create these directories:

   $ sudo mkdir -p /usr/local/etc/pkg/angie/ /usr/local/etc/pkg/repos/
   

2. To configure the repo, create a file named /usr/local/etc/pkg/repos/angie.conf with the following contents:

   angie: {
      url: "https://download.angie.software/angie/freebsd/${VERSION_MAJOR}/${ARCH}",
      signature_type: "pubkey",
      pubkey: "/usr/local/etc/pkg/angie/angie-signing.rsa",
      enabled: yes
   }
   

3. Download the public key of the Angie repo for package verification:

   $ sudo curl -o /etc/apt/trusted.gpg.d/angie-signing.gpg \
               https://angie.software/keys/angie-signing.gpg
   

4. Update the repo indexes:

   $ sudo pkg update
   

5. Install the Angie package:

   $ sudo pkg install -y angie
   

6. (Optional) Install the dynamic module packages you need:

   $ sudo pkg install -y <PACKAGE NAME>
   

7. Start the service:

   $ sudo service angie start
   

8. To autostart Angie on server reboot:

   $ sudo sysrc angie_enable=YES
   

openSUSE

1. To add the repo, create a file named /etc/zypp/repos.d/angie.repo with the following contents:

   [angie]
   name=Angie repo
   baseurl=https://download.angie.software/angie/opensuse/$releasever_major/
   gpgcheck=1
   enabled=1
   gpgkey=https://angie.software/keys/angie-signing.gpg.asc
   

2. Update the repo indexes:

   $ sudo zypper refresh
   

3. Install the Angie package:

   $ sudo zypper install -y angie
   

4. (Optional) Install the dynamic module packages you need:

   $ sudo zypper install -y <PACKAGE NAME>
   

5. Start the service:

   $ sudo systemctl start angie
   

6. To autostart Angie after server reboot:

   $ sudo systemctl enable angie
   

Dynamic Modules

To extend Angie’s basic functionality, you can add a variety of dynamic modules, available as ready-made packages from our repository.

Modules can also be built from source code; compile them against the corresponding Angie version.

Dynamic module packages distributed as part of Angie:

angie-module-image-filter	Adds a filter to transform .jpeg, .gif, .png, and .webp images.
angie-module-njs: http_js_module, stream_js_module	Enable using njs (a JavaScript subset) in Angie configuration in the http and stream contexts, respectively.
angie-module-perl	Enables writing location and variable handlers in Perl, and also invoking Perl from SSI.
angie-module-xslt	Adds a filter to transform XML responses with XSLT stylesheets.

We also build and publish in our repository the following third-party module packages:

angie-module-auth-jwt	Adds client JWT authentication.
angie-module-auth-ldap	Adds support for authentication against multiple LDAP servers.
angie-module-auth-spnego	Adds SPNEGO, GSSAPI support.
angie-module-brotli	Enables Brotli for dynamic and static response compression.
angie-module-cache-purge	Enables purging FastCGI, proxy, SCGI, and uWSGI cache contents.
angie-module-dav-ext	Extends WebDAV method support, adding PROPFIND and OPTIONS.
angie-module-dynamic-limit-req	Used to dynamically lock IPs and release them periodically.
angie-module-echo	Enables echo, sleep, time, exec, and other shell-style commands in the configuration file.
angie-module-enhanced-memcached	Enhances the capabilities of the built-in http_memcached module.
angie-module-eval	Enables capturing subrequest response bodies in variables.
angie-module-geoip2: http_geoip2, stream_geoip2	Enables geodata lookup in the MaxMind GeoIP2 database.
angie-module-headers-more	Enables setting and clearing input and output headers.
angie-module-keyval	Enables variables created from key-value pairs.
angie-module-lua: http_lua_module, stream_lua_module	Enable using Lua in Angie configuration in the http and stream contexts, respectively.
angie-module-modsecurity	Adds a connector that enables ModSecurity rules. Note The package needs extra setup.
angie-module-ndk	Adds Nginx Development Kit (NDK) for module development.
angie-module-otel	Enables sending telemetry data to an OpenTelemetry collector.
angie-module-opentracing	Adds distributed tracing of Angie requests via OpenTracing; includes data export plugins for Zipkin and DataDog.
angie-module-postgres	Enables direct communication with PostgreSQL databases.
angie-module-redis2	Enables Redis 2.0 for HTTP upstreams.
angie-module-rtmp	Enables RTMP for live streaming and video on demand.
angie-module-set-misc	Adds various set_xxx directives to the rewrite module.
angie-module-subs	Enables regex string substitutions in the HTTP response body.
angie-module-testcookie	Enables robot mitigation using a cookie-based challenge-response mechanism.
angie-module-upload	Adds the multipart/form-data encoding (RFC 1867) for file upload, enabling resumable uploads.
angie-module-vod	Enables repackaging .mp4 files for HLS, HDS, MSS, and DASH streaming.
angie-module-zip	Enables assembling ZIP archives dynamically.
angie-module-zstd	Enables Zstandard compression.

To use an installed module in the configuration, load it with the load_module directive.

Docker Images (OSS)

To run Angie in a Docker container, use an image from our registry:

docker.angie.software/angie
docker.angie.software/angie:latest
docker.angie.software/angie:1.5.0
docker.angie.software/angie:1.5.0-minimal
docker.angie.software/angie:1.5.0-alpine
docker.angie.software/angie:1.5.0-centos
docker.angie.software/angie:1.5.0-debian
docker.angie.software/angie:1.5.0-oracle
docker.angie.software/angie:1.5.0-rocky
docker.angie.software/angie:1.5.0-ubuntu

To start a container with Angie at port 8080, enabling read-only access to the /var/www/ static file directory and the angie.conf file in the current working directory:

$ docker run --rm --name angie -v /var/www:/usr/share/angie/html:ro \
    -v $(pwd)/angie.conf:/etc/angie/angie.conf:ro -p 8080:80 -d docker.angie.software/angie:latest

$ curl -I localhost:8080

    HTTP/1.1 200 OK
    Server: Angie/1.5.0
    Date: Wed, 27 Mar 2024 10:42:54 GMT
    Content-Type: text/html
    Content-Length: 543
    Last-Modified: Wed, 27 Mar 2024 09:12:23 GMT
    Connection: keep-alive
    ETag: "64c3ccc7-21f"
    Accept-Ranges: bytes

Setups like this can be used for local development and configuration.

Also, you can build your own image based on a supported distro, adding the Angie layer with packages or source code. A couple of such Dockerfile examples:

Debian, using Angie packages

FROM debian:12

LABEL org.opencontainers.image.authors="Release Engineering Team <devops@tech.wbsrv.ru>"

ARG DEBIAN_FRONTEND=noninteractive

RUN set -x \
     && apt-get update \
     && apt-get install --no-install-recommends --no-install-suggests -y \
          ca-certificates lsb-release curl \
     && curl -o /etc/apt/trusted.gpg.d/angie-signing.gpg \
          https://angie.software/keys/angie-signing.gpg \
     && echo "deb https://download.angie.software/angie/debian/ `lsb_release \
           -cs` main" > /etc/apt/sources.list.d/angie.list \
     && apt-get update \
     && apt-get install --no-install-recommends --no-install-suggests -y \
          angie angie-module-geoip2 angie-module-njs \
     && apt-get remove --auto-remove --purge -y lsb-release \
     && rm -Rf /var/lib/apt/lists \
          /etc/apt/sources.list.d/angie.list \
          /etc/apt/trusted.gpg.d/angie-signing.gpg \
     && ln -sf /dev/stdout /var/log/angie/access.log \
     && ln -sf /dev/stderr /var/log/angie/error.log

EXPOSE 80

CMD ["angie", "-g", "daemon off;"]

Alpine, using Angie packages

FROM alpine:3.19

LABEL org.opencontainers.image.authors="Release Engineering Team <devops@tech.wbsrv.ru>"

RUN set -x \
     && apk add --no-cache ca-certificates curl \
     && curl -o /etc/apk/keys/angie-signing.rsa https://angie.software/keys/angie-signing.rsa \
     && echo "https://download.angie.software/angie/alpine/v$(egrep -o \
          '[0-9]+\.[0-9]+' /etc/alpine-release)/main" >> /etc/apk/repositories \
     && apk add --no-cache angie angie-module-geoip2 angie-module-njs \
     && rm /etc/apk/keys/angie-signing.rsa \
     && ln -sf /dev/stdout /var/log/angie/access.log \
     && ln -sf /dev/stderr /var/log/angie/error.log

EXPOSE 80

CMD ["angie", "-g", "daemon off;"]

To build a myangie image in the Dockerfile’s directory and start a container in the same way as described above:

$ docker build -t myangie .
$ docker run --rm --name myangie -v /var/www:/usr/share/angie/html:ro \
    -v $(pwd)/angie.conf:/etc/angie/angie.conf:ro -p 8080:80 -d myangie

Building From Source (OSS)

We recommend installing Angie from packages. If you still need your own build:

1. Download the .tar.gz archive from our website:

   $ curl -O https://download.angie.software/files/angie-1.5.0.tar.gz
   

2. Unpack the sources and enter the code directory:

   $ tar -xpf angie-1.5.0.tar.gz
   $ cd angie-1.5.0
   

3. To prepare the build, use the configure script to determine the specific traits of the OS where the build occurs, in particular, the methods that Angie can use to handle connections. After a successful run, the script creates a Makefile.

   Before running configure, browse the options to choose the optimal layout:

   $ ./configure <OPTIONS>
   

4. When Makefile is ready, build and install Angie:

   $ make
   $ make install
   

configure Options

General

Parameter	Default
--help prints a help message.
--user=name sets the name of an unprivileged user whose credentials will be used by worker processes. After installation, the name can always be changed in the angie.conf configuration file using the user directive.	nobody
--group=name sets the name of a group whose credentials will be used by worker processes. After installation, the name can always be changed in the angie.conf configuration file using the user directive.	is set to the name of an unprivileged user
--build=name sets an optional Angie build name.
--builddir=path sets a build directory.	objs

Paths

Parameter	Default
--prefix=path defines a directory that will keep server files. This same directory will also be used for all relative paths set by configure (except for paths to libraries sources) and in the angie.conf configuration file.	/usr/local/angie
--sbin-path=path sets the name of an Angie executable file. This name is used only during installation.	<prefix>/sbin/angie
--modules-path=path defines a directory where Angie dynamic modules will be installed.	<prefix>/modules
--conf-path=path sets the name of an angie.conf configuration file. If needs be, Angie can always be started with a different configuration file, by specifying it in the command-line parameter -c file.	<prefix>/conf/angie.conf
--error-log-path=path sets the name of the primary error, warnings, and diagnostic file. After installation, the file name can always be changed in the angie.conf configuration file using the error_log directive.	<prefix>/logs/error.log
--pid-path=path sets the name of an angie.pid file that will store the process ID of the main process. After installation, the file name can always be changed in the angie.conf configuration file using the pid directive.	<prefix>/logs/angie.pid
--lock-path=path sets a prefix for the names of lock files. After installation, the value can always be changed in the angie.conf configuration file using the lock_file directive.	<prefix>/logs/angie.lock
--http-acme-client-path=path sets the directory to store certificates and keys obtained for server blocks that have acme directives defined.	<prefix>/acme_client
--http-log-path=path sets the name of the primary request log file of the HTTP server. After installation, the file name can always be changed in the angie.conf configuration file using the access_log directive.	<prefix>/logs/access.log
--http-client-body-temp-path=path defines a directory for storing temporary files that hold client request bodies. After installation, the directory can always be changed in the angie.conf configuration file using the client_body_temp_path directive.	<prefix>/client_body_temp
--http-proxy-temp-path=path defines a directory for storing temporary files with data received from proxied servers. After installation, the directory can always be changed in the angie.conf configuration file using the proxy_temp_path directive.	<prefix>/proxy_temp
--http-fastcgi-temp-path=path defines a directory for storing temporary files with data received from FastCGI servers. After installation, the directory can always be changed in the angie.conf configuration file using the fastcgi_temp_path directive.	<prefix>/fastcgi_temp
--http-uwsgi-temp-path=path defines a directory for storing temporary files with data received from uwsgi servers. After installation, the directory can always be changed in the angie.conf configuration file using the uwsgi_temp_path directive.	<prefix>/uwsgi_temp
--http-scgi-temp-path=path defines a directory for storing temporary files with data received from SCGI servers. After installation, the directory can always be changed in the angie.conf configuration file using the scgi_temp_path directive.	<prefix>/scgi_temp

Features and dependencies

--with-select_module / --without-select_module enables or disables building a module that allows the server to work with the select() method. This module is built automatically if the platform does not appear to support more appropriate methods such as kqueue, epoll, or /dev/poll.

--with-poll_module / --without-poll_module enables or disables building a module that allows the server to run using poll(). The module is built automatically if the platform doesn’t support more suitable methods such as kqueue, epoll, or /dev/poll.

--with-threads enables the use of thread pools.

--with-file-aio enables the use of asynchronous file I/O (AIO) on FreeBSD and Linux.

--with-debug enables the debugging log.

--without-http-cache disables HTTP cache.

--with-pcre fsets the path to the sources of the PCRE library. The library distribution needs to be downloaded from the PCRE site and extracted. The rest is done by angie’s ./configure and make. The library is required for regular expressions support in the location directive and for the http_rewrite module. --with-pcre-opt=parameters sets additional build options for PCRE. --with-pcre-jit builds the PCRE library with “just-in-time compilation” support (the pcre_jit directive).

--without-pcre disables the usage of the PCRE library.

--without-pcre2 disables use of the PCRE2 library instead of the original PCRE library.

--with-libatomic forces the libatomic_ops library usage. --with-libatomic=path sets the path to the libatomic_ops library sources.

--with-openssl=path enables and sets the path to the OpenSSL library sources. --with-openssl-opt=parameters sets additional build options for OpenSSL.

--with-ntls enables server-side and client-side NTLS support in the HTTP and stream (server-side, client_side when linked with NTLS-enabled SSL library.

--with-zlib=path sets the path to the sources of the zlib library. The library distribution (version 1.1.3 — 1.2.11) needs to be downloaded from the zlib site and extracted. The rest is done by Angie’s ./configure and make. The library is required for the http_gzip module. --with-zlib-opt=parameters sets additional build options for zlib. --with-zlib-asm=cpu enables the use of the zlib assembler sources optimized for one of the specified CPUs: pentium, pentiumpro.

Angie Modules

http

Enabling additional modules

--with-http_acme_module enables building the http_acme module that enables the ACME protocol.

--with-http_addition_module enables building the http_addition module that adds text before and after a response.

--with-http_auth_request_module enables building the http_auth_request module that implements client authorization based on the result of a subrequest.

--with-http_dav_module enables building the http_dav module that provides file management automation via the WebDAV protocol.

--with-http_degradation_module enables building the http_degradation module.

--with-http_flv_module enables building the http_flv module that provides pseudo-streaming server-side support for Flash Video (FLV) files.

--with-http_geoip_module / --with-http_geoip_module=dynamic enables building the http_geoip module that creates variables depending on the client IP address and the precompiled MaxMind databases.

--with-http_gunzip_module enables building the http_gunzip module that decompresses responses with “Content-Encoding: gzip” for clients that do not support gzip encoding method.

--with-http_gzip_static_module enables building the http_gzip_static module that enables sending precompressed files with the “.gz” filename extension instead of regular files.

--with-http_image_filter_module / --with-http_image_filter_module=dynamic enables building the http_image_filter module that transforms images in JPEG, GIF, PNG, and WebP formats.

--with-http_mp4_module enables building the http_mp4 module that provides pseudo-streaming server-side support for MP4 files.

--with-http_perl_module / --with-http_perl_module=dynamic enables building the embedded Perl module. --with-perl_modules_path=path defines a directory that will keep Perl modules. --with-perl=path sets the name of the Perl binary.

--with-http_random_index_module enables building the http_random_index module that processes requests ending with the slash character (/) and picks a random file in a directory to serve as an index file.

--with-http_realip_module enables building the http_realip module that changes the client address to the address sent in the specified header field.

--with-http_secure_link_module enables building the http_secure_link module.

--with-http_slice_module enables building the http_slice module that splits a request into subrequests, each returning a certain range of response. The module provides more effective caching of big responses.

--with-http_ssl_module enables building a module that adds the HTTPS protocol support to an HTTP server. The OpenSSL library is required to build and run this module.

--with-http_stub_status_module enables building the http_stub_status module that provides access to basic status information.

--with-http_sub_module enables building the http_sub module that modifies a response by replacing one specified string by another.

--with-http_v2_module enables building a module that provides support for HTTP/2.

--with-http_v3_module enables building a module that provides support for HTTP/3. An SSL library that provides HTTP/3 support is recommended to build and run this module, such as BoringSSL, LibreSSL, or QuicTLS. Otherwise, if using the OpenSSL library, OpenSSL compatibility layer will be used that does not support QUIC early data.

--with-http_xslt_module / --with-http_xslt_module=dynamic enables building the http_xslt module that transforms XML responses using one or more XSLT stylesheets. The libxml2 and libxslt libraries are required to build and run this module.

--with-google_perftools_module enables building the google_perftools module that enables profiling of Angie worker processes using Google Performance Tools. The module is intended for Angie developers.

Disable standard modules

--without-http disables the HTTP server.

--without-http_access_module disables building the http_access module that allows limiting access to certain client addresses.

--without-http_api_module disables building a module API, providing HTTP RESTful interface for accessing in JSON format information about a web server instance.

--without-http_auth_basic_module disables building the http_auth_basic module that allows limiting access to resources by validating the user name and password using the “HTTP Basic Authentication” protocol.

--without-http_autoindex_module disables building the http_autoindex module that processes requests ending with the slash character (/) and produces a directory listing in case the http_index module cannot find an index file.

--without-http_browser_module disables building the http_browser module that creates variables whose values depend on the value of the “User-Agent” request header field.

--without-http_charset_module disables building the http_charset module that adds the specified charset to the “Content-Type” response header field and can additionally convert data from one charset to another.

--without-http_empty_gif_module disables building a module that emits single-pixel transparent GIF.

--without-http_fastcgi_module disables building the http_fastcgi module that passes requests to a FastCGI server.

--without-http_geo_module disables building the http_geo module that creates variables with values depending on the client IP address.

--without-http_gzip_module disables building a module that compresses responses of an HTTP server. The zlib library is required to build and run this module.

--without-http_grpc_module disables building the http_grpc module that passes requests to a gRPC server.

--without-http_limit_conn_module disables building the http_limit_conn module that limits the number of connections per key, for example, the number of connections from a single IP address.

--without-http_limit_req_module disables building the http_limit_req module that limits the request processing rate per key, for example, the processing rate of requests coming from a single IP address.

--without-http_map_module disables building the http_map module that creates variables with values depending on values of other variables.

--without-http_memcached_module disables building the http_memcached module that obtains responses from a memcached server.

--without-http_mirror_module disables building the http_mirror module that implements mirroring of an original request by creating background mirror subrequests.

--without-http_proxy_module disables building an HTTP server proxying module.

--without-http_prometheus_module disables building the Prometheus module for the HTTP server.

--without-http_referer_module disables building the http_referer module that can block access to a site for requests with invalid values in the “Referer” header field.

--without-http_rewrite_module disables building a module that allows an HTTP server to redirect requests and change URI of requests. The PCRE library is required to build and run this module.

--without-http_scgi_module disables building the http_scgi module that passes requests to an SCGI server.

--without-http_split_clients_module disables building the http_split_clients module that creates variables for A/B testing.

--without-http_ssi_module disables building the http_ssi module that processes SSI (Server Side Includes) commands in responses passing through it.

--without-http_upstream_hash_module disables building a module that implements the hash load balancing method.

--without-http_upstream_ip_hash_module disables building a module that implements the ip_hash load balancing method.

--without-http_upstream_keepalive_module disables building a module that provides caching of connections to upstream servers.

--without-http_upstream_least_conn_module disables building a module that implements the least_conn load balancing method.

--without-http_upstream_random_module disables building a module that implements the random load balancing method.

--without-http_upstream_sticky_module disables building a module that implements session persistence functionality, ensuring all requests in the client session are passed to the same backend server in upstream group.

--without-http_upstream_zone_module disables building a module that makes it possible to store run-time state of an upstream group in a shared memory zone.

--without-http_userid_module disables building the http_userid module that sets cookies suitable for client identification.

--without-http_uwsgi_module disables building the http_uwsgi module that passes requests to a uwsgi server.

stream

Enable additional modules

--with-stream / --with-stream=dynamic enables building the stream_core module for generic TCP/UDP proxying and load balancing.

--with-stream_geoip_module / --with-stream_geoip_module=dynamic enables building the stream_geoip module that creates variables depending on the client IP address and the precompiled MaxMind databases.

--with-stream_realip_module enables building the stream_realip module that changes the client address to the address sent in the PROXY protocol header.

--with-stream_ssl_module enables building a module that adds the SSL/TLS protocol support to the stream module. The OpenSSL library is required to build and run this module.

--with-stream_ssl_preread_module enables building the stream_ssl_preread module that allows extracting information from the ClientHello message without terminating SSL/TLS.

--with-stream_mqtt_preread_module enables building the stream_mqtt_preread module that allows extracting client IDs and usernames from CONNECT packets in MQTT versions 3.1.1 and 5.0.

Disable standard modules

--without-stream_access_module disables building the stream_access module that allows limiting access to certain client addresses.

--without-stream_geo_module disables building the stream_geo module that creates variables with values depending on the client IP address.

--without-stream_limit_conn_module disables building the stream_limit_conn module that limits the number of connections per key, for example, the number of connections from a single IP address.

--without-stream_map_module disables building the stream_map module that creates variables with values depending on values of other variables.

--without-stream_return_module disables building the stream_return module that sends some specified value to the client and then closes the connection.

--without-stream_set_module disables building the stream_set module that sets a value for a variable.

--without-stream_split_clients_module disables building the stream_split_clients module that creates variables for A/B testing.

--without-stream_upstream_hash_module disables building a module that implements the hash load balancing method.

--without-stream_upstream_least_conn_module disables building a module that implements the least_conn load balancing method.

--without-stream_upstream_random_module disables building a module that implements the random load balancing method.

--without-stream_upstream_zone_module disables building a module that makes it possible to store run-time state of an upstream group in a shared memory zone.

mail

Enable additional modules

--with-mail / --with-mail=dynamic enables POP3/IMAP4/SMTP mail proxy server.

--with-mail_ssl_module enables building a module that adds the SSL/TLS protocol support to the mail proxy server. The OpenSSL library is required to build and run this module.

Disable standard modules

--without-mail_imap_module disables the IMAP protocol in mail proxy server.

--without-mail_pop3_module disables the POP3 protocol in mail proxy server.

--without-mail_smtp_module disables the SMTP protocol in mail proxy server.

Build options

--with-cpp_test_module enables building the ngx_cpp_test_module.

--add-module=path enables an external module.

--add-dynamic-module=path enables an external dynamic module.

--with-compat enables dynamic modules compatibility.

--with-cc=path sets the name of the C compiler.

--with-cpp=path sets the name of the C preprocessor.

--with-cc-opt=parameters sets additional parameters that will be added to the CFLAGS variable. When using the system PCRE library under FreeBSD, ‑‑with‑cc‑opt="‑I /usr/local/include" should be specified. If the number of files supported by select() needs to be increased it can also be specified here such as this: ‑‑with‑cc‑opt="‑D FD_SETSIZE=2048".

--with-ld-opt=parameters sets additional parameters that will be used during linking. When using the system PCRE library under FreeBSD, ‑‑with‑ld‑opt="‑L /usr/local/lib" should be specified.

--with-cpu-opt=cpu enables building per specified CPU: pentium, pentiumpro, pentium3, pentium4, athlon, opteron, sparc32, sparc64, ppc64.

Example of parameters usage

./configure \
     --sbin-path=/usr/sbin/angie/ \
     --conf-path=/etc/angie/angie.conf \
     --pid-path=/run/angie.pid \
     --with-http_ssl_module \
     --with-pcre=../pcre2-10.40 \
     --with-zlib=../zlib-1.3