Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust.

Overview

Actix Web

Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust

crates.io Documentation Version MIT or Apache 2.0 licensed Dependency Status
build status codecov downloads Chat on Discord

Features

  • Supports HTTP/1.x and HTTP/2
  • Streaming and pipelining
  • Keep-alive and slow requests handling
  • Client/server WebSockets support
  • Transparent content compression/decompression (br, gzip, deflate)
  • Powerful request routing
  • Multipart streams
  • Static assets
  • SSL support using OpenSSL or Rustls
  • Middlewares (Logger, Session, CORS, etc)
  • Includes an async HTTP client
  • Runs on stable Rust 1.46+

Documentation

Example

Dependencies:

[dependencies]
actix-web = "3"

Code:

use actix_web::{get, web, App, HttpServer, Responder};

#[get("/{id}/{name}/index.html")]
async fn index(web::Path((id, name)): web::Path<(u32, String)>) -> impl Responder {
    format!("Hello {}! id:{}", name, id)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| App::new().service(index))
        .bind("127.0.0.1:8080")?
        .run()
        .await
}

More examples

You may consider checking out this directory for more examples.

Benchmarks

One of the fastest web frameworks available according to the TechEmpower Framework Benchmark.

License

This project is licensed under either of

at your option.

Code of Conduct

Contribution to the actix-web repo is organized under the terms of the Contributor Covenant. The Actix team promises to intervene to uphold that code of conduct.

Comments
  • Project future

    Project future

    I realized, a lot of people depends on actix. And it would be unfair to just delete repos. I promote @JohnTitor to project leader. He did very good job helping me for the last year. I hope new community of developers emerge. And good luck!

    opened by fafhrd91 143
  • Connection not closed correctly

    Connection not closed correctly

    Connection are not closed correctly by default What I means is: if you do a "netstat -ano" you will see connection list growing and growing. Not all old connection get closed.

    Tested with StaticFile handler ( HTTP2 or not ) on a website with ~20k+ daily users

    With the default config -> Not closed correctly With .keep_alive(None) -> Not closed correctly With .keep_alive(server::KeepAlive::Timeout(5)) -> All connections are closed correctly

    Initially detected in this ticket #426 but it was not the main issue

    C-bug needs-investigation 
    opened by neowutran 116
  • StaticFile & memory leak

    StaticFile & memory leak

    Hi, I am playing a bit with rust/actix-web on my personal website. The code is very basic https://git.neowutran.ovh:8080/neowutran/Website/src/master/src/main.rs

      server::new(|| {
        App::new()
         // .middleware(middleware::Logger::default())
          .resource("/store_stats", |r| {
            r.method(Method::POST)
              .with_config(store_statistics, |config| {
                config.limit(MAX_SIZE_STATS);
              })
          })
        .resource("/store_packets", |r| {
          r.method(Method::POST)
            .with_config(store_packets, |config| {
                config.0.limit(MAX_SIZE_PACKET);
            })
        })
        .handler("/updates",StaticFiles::new("/home/gl0/updates/").unwrap().show_files_listing())
        .handler("/others",StaticFiles::new("/home/gl0/others/").unwrap().show_files_listing())
        .handler("/teraDB",StaticFiles::new("/home/gl0/teraDB/").unwrap().show_files_listing())
        .handler("/",StaticFiles::new("/home/http/neowutran/").unwrap().show_files_listing().index_file("index.html"))
      })
    

    I run 2 instance of this exact same code. One on port 443, one on port 8083

    On port 8083, only /store_packets and /store_stats are used. 0.2% of server memory, stable. Actively used ( ~thousands request by hours, gigabytes uploaded ). Ok.

    On port 443, only the StaticFiles handler are used: /updates, /others, /teraDB, / ( TLS + HTTP2 ) Very actively used (~15k user use the /updates to download things). When I launched it yesterday, it used 0.2% of server memory. Memory used increased over time. Now, after ~15h, it now use 10% of server memory. With the command netstat -ano, I see that a lot of connections (hundreds) are "ESTABLISHED" on the service. Maybe in the case of HTTP2 / TLS, some issues with connection not being released or something like that ? ( For the same thing with apache httpd, ~0.2% of server memory, stable )

    Thanks

    opened by neowutran 53
  • actix-web 1.0

    actix-web 1.0

    I am planing to move 0.7 to separate branch and move 1.0 to master in 1 week.

    Any thoughts, concerns?

    High level tasks:

    • [x] Move 0.7 to separate branch
    • [x] Move 1.0 to master
    • [x] actix-files tidy up #730
    • [x] Migration guide 0.7 -> 1.0
    • [x] Upgrade the book
    • [x] Upgrade example
    opened by fafhrd91 51
  • Memory Leak on Actix 3.2.0

    Memory Leak on Actix 3.2.0

    I'm creating a simple API and put it under stress using loadtest. The API consumes 3MB when idling and not under stress. With the command: loadtest -c 1000 --rps 10000 http://localhost:4000/hello/world the memory consumption goes to ~100MB.

    Expected Behavior

    After the stress test done, the memory consumption goes back to a normal level (~3MB)

    Current Behavior

    After the stress test done, the memory consumption doesn't decrease.

    Possible Solution

    Sorry I can't find any solution for this.

    Steps to Reproduce (for bugs)

    1. Implement a simple API and call the exposed route.

    Context

    I tried to make a benchmark of an API made in Rust vs a one in Spring, and while the rust version is memory efficient, it does show some leaks that are problematic.


    Code used for exposing the route.

    use actix_web::{middleware, web, App, HttpServer, Responder, HttpResponse};
    
    async fn hello_world(
        name: web::Path<String>
    ) -> impl Responder {
        HttpResponse::Ok().json(format!("{}", name))
    }
    
    #[actix_web::main]
    async fn main() -> std::io::Result<()> {
    
        println!("Launching server...");
    
        std::env::set_var("RUST_LOG", "actix_web=info,actix_server=info");
        env_logger::init();
        dotenv::dotenv().ok();
    
        let port = match std::env::var("PORT") {
            Ok(port) => port,
            _ => String::from("4000")
        };
        let address = format!("0.0.0.0:{}", port);
    
        let http_server = HttpServer::new(move || {
            App::new()
                // .wrap(middleware::Logger::default())
                .route("/hello/{name}", web::get().to(hello_world))
        })
            .bind(address.clone())?;
    
        println!("Will listen to {}", address);
    
        http_server
            .run()
            .await
    }
    

    Using LeakSanitizer it does confirm that there's a little problem:

    ==68512==ERROR: LeakSanitizer: detected memory leaks
    Direct leak of 256 byte(s) in 8 object(s) allocated from:
        #0 0x564cae1e4255  (/home/lperreau/workspace/hello-world/target/x86_64-unknown-linux-gnu/debug/hello_world+0xd6255)
        #1 0x564cae2f830b  (/home/lperreau/workspace/hello-world/target/x86_64-unknown-linux-gnu/debug/hello_world+0x1ea30b)
    
    Direct leak of 192 byte(s) in 8 object(s) allocated from:
        #0 0x564cae1e4255  (/home/lperreau/workspace/hello-world/target/x86_64-unknown-linux-gnu/debug/hello_world+0xd6255)
        #1 0x564cae40bf8b  (/home/lperreau/workspace/hello-world/target/x86_64-unknown-linux-gnu/debug/hello_world+0x2fdf8b)
    
    Indirect leak of 8192 byte(s) in 8 object(s) allocated from:
        #0 0x564cae1e4255  (/home/lperreau/workspace/hello-world/target/x86_64-unknown-linux-gnu/debug/hello_world+0xd6255)
        #1 0x564cae2f830b  (/home/lperreau/workspace/hello-world/target/x86_64-unknown-linux-gnu/debug/hello_world+0x1ea30b)
    
    Indirect leak of 32 byte(s) in 8 object(s) allocated from:
        #0 0x564cae1e4255  (/home/lperreau/workspace/hello-world/target/x86_64-unknown-linux-gnu/debug/hello_world+0xd6255)
        #1 0x564cae565a5b  (/home/lperreau/workspace/hello-world/target/x86_64-unknown-linux-gnu/debug/hello_world+0x457a5b)
    
    SUMMARY: LeakSanitizer: 8672 byte(s) leaked in 32 allocation(s).
    

    Your Environment

    • Rust Version (I.e, output of rustc -V): rustc 1.45.1 (c367798cf 2020-07-26)
    • Actix Web Version: 3.2.0
    C-perf-mem A-web 
    opened by Mcfloy 41
  • Remove several usages of 'unsafe'

    Remove several usages of 'unsafe'

    This PR removes several different usages of unsafe (specifically, UnsafeCell), and replaces them with safe code. While these changes technically add some amount of overhead (Copying a type instead of taking a reference, and runtime RefCell checks), it should be so small as to be invisible on any benchmark.

    By replacing UnsafeCell with the safe Cell/UnsafeCell types, we ensure that any mistakes will lead to a panic! at worst, instead of undefined behavior.

    Each commit modifies a single file, and describes the changes made.

    opened by Aaron1011 41
  • how to run server by #[tokio::main]

    how to run server by #[tokio::main]

    use actix_web::{middleware, web, App, HttpRequest, HttpServer};

    async fn index(_req: HttpRequest) -> &'static str { "Hello world!" }

    #[tokio::main] #[cfg(unix)] async fn main() -> std::io::Result<()> { ::std::env::set_var("RUST_LOG", "actix_server=info,actix_web=info"); env_logger::init();

    HttpServer::new(|| {
        App::new()
            // enable logger - always register actix-web Logger middleware last
            .wrap(middleware::Logger::default())
            .service(
                web::resource("/index.html")
                    .route(web::get().to(|| async { "Hello world!" })),
            )
            .service(web::resource("/").to(index))
    })
    .bind_uds("/tmp/actix-uds.socket")?
    .run()
    .await
    

    }

    #[cfg(not(unix))] fn main() -> std::io::Result<()> { println!("not supported"); Ok(()) }

    opened by IThawk 39
  • bug: actix_web client unable to connect to any host on windows

    bug: actix_web client unable to connect to any host on windows

    Following example code always produces Error: Connect(Timeout):

    use actix_rt::System;
    use awc::Client;
    use futures::future::{
        Future,
        lazy
    };
    
    fn main() {
        System::new("weight_version").block_on(lazy(|| {
    
            awc::Client::new().get("https://google.com") //any address here
                .header("User-Agent", "Actix-web")
                .send()
                .map_err(|error| {
                    println!("Error: {:?}", error);
                })
                .and_then(|response| {
                    println!("Response: {:?}", response);
                    Ok(())
                })
        }));
    }
    

    actix_web::client::Client also produces same error:

    use actix_rt::System;
    use actix_web::client::Client;
    use futures::future::{
        Future,
        lazy
    };
    
    fn main() {
        System::new("weight_version").block_on(lazy(|| {
            let client = Client::default();
    
            client.get("https://www.rust-lang.org/")
                .header("User-Agent", "Actix-web")
                .send()
                .map_err(|error| {
                    println!("Error: {:?}", error);
                    //Err(error)
                })
                .and_then(|response| {
                    println!("Response: {:?}", response);
                    Ok(())
                })
        }));
    }
    

    Tested on 3 totally different windows machines with following:

    openssl version
    OpenSSL 1.1.1c  28 May 2019
    
    needs-investigation A-awc O-windows O-macos v1.x 
    opened by calirofpn 38
  • Call to Community and Participation

    Call to Community and Participation

    Until now i made most of project related decisions. But unfortunately, i dont have much time anymore, also i'd like to spend more time outside of opensource. supporting of this large and complex project is time consuming so i'd like to hand it to contributors, who'd like to spend some time on the project. I am still planing to work on actix, but can not afford to spend that much time as before.

    @actix/contributors

    opened by fafhrd91 37
  • Type-safe path/query parameter handling, using serde

    Type-safe path/query parameter handling, using serde

    Users should be able to define structures that hold parameters that need to be passed to a request handler. We could use the serde Deserialize trait. The goal is to make it easier for users to access parameters without having to deal with error-handling themselves, and hopefully to avoid the current situation where making a typo in your handler vs your route means that you get a runtime error instead of a compile-time error.

    The goal is to somehow allow the user to type this:

    #[derive(Deserialize)]
    struct MyParams {
        name: String,
    }
    

    and then, define a handler like this:

    fn my_handler(req: HttpRequest<_>, my_params: MyParams) -> _ {
    }
    

    or, alternatively:

    fn my_hadler(req: HttpRequest<_>) -> _ {
        let my_params = req.get_params::<MyParams>();
    }
    

    This will require some way to declare the route for my_handler with MyParams.

    opened by radix 37
  • UDP Socket Leak

    UDP Socket Leak

    I have a service that after ~18 - 24 hours runs out of file descriptors after a lot of investigation and some production debugging we were able to track it down to being leaked UDP sockets. My first thought is something about DNS resolution is wrong. When caught in the act the server had 418 UDP sockets open and it climbs up to the ulimit of 1024 and then server CPU spikes and the health check fails and the container is cycled.

    C-bug-upstream 
    opened by glademiller 35
  • Not panic if bind failed

    Not panic if bind failed

    This only exists on windows platforms.

    Expected Behavior

    Panic if can not bind to port

    Current Behavior

    continue runs, but can not really listen

    Steps to Reproduce (for bugs)

    1. build
    2. run at least 2

    Context

    My code: HttpServer::new(|| { App::new() .service(echo) .service(user::login_request) .service(user::register_request) .service(user::verify_email_request) }).bind(("0.0.0.0", unsafe { &CONFIG }["connection"]["serverPort"].as_i64().unwrap() as u16)).expect("Can not bind server to port").run().await.expect("Can not start server");

    Your Environment

    Windows 10 22H2 19045.2364

    • Rust Version (I.e, output of rustc -V): rustc 1.68.0-nightly (77429957a 2023-01-01)
    • Actix-* crate(s) Version: { version = "4.2.1", features = ["rustls"] }
    opened by zrll12 0
  • Hide authorization header in httprequest debug output

    Hide authorization header in httprequest debug output

    PR Type

    Bug fix

    PR Checklist

    • [X] Tests for the changes have been added / updated.
    • [X] Documentation comments have been added / updated.
    • [X] A changelog entry has been made for the appropriate packages.
    • [X] Format code with the latest stable rustfmt.
    • [x] (Team) Label with affected crates and semver status.

    Overview

    Hides Authorization header from HTTPRequest Debug output. In the case of HTTP Basic Authentication, this header would have the username and password of the authenticated user. Preventing this header from showing up in debug would prevent this password leakage into the logs. In other schemes the value may not be as sensitive, but still in most cases would allow impersonation of the user in some form.

    Whether or not you want this conditional or not is of course up to you. Willing to consider other locations for this check if you want a more general approach to prevent all debug outputs of sensitive headers.

    Thanks for a great library, keep it up!

    B-semver-patch A-web 
    opened by nshaaban-cPacket 3
  • minor optimization: reserve buffer once length is known (ws)

    minor optimization: reserve buffer once length is known (ws)

    PR Type

    Other

    PR Checklist

    • [x] ~Tests for the changes have been added / updated.~
    • [x] ~Documentation comments have been added / updated.~
    • [x] ~A changelog entry has been made for the appropriate packages.~
    • [X] Format code with the latest stable rustfmt.
    • [x] (Team) Label with affected crates and semver status.

    Overview

    No behavior change. Just an optimization.

    No breaking changes.

    A-http B-semver-norelease 
    opened by moh-eulith 0
  • add setup to compress middleware

    add setup to compress middleware

    PR Type

    Feature

    PR Checklist

    • [ ] Tests for the changes have been added / updated.
    • [ ] Documentation comments have been added / updated.
    • [ ] A changelog entry has been made for the appropriate packages.
    • [x] Format code with the latest stable rustfmt.
    • [ ] (Team) Label with affected crates and semver status.

    Overview

    A-http B-semver-minor A-web 
    opened by topenkoff 0
  • Update tokio-uring to 0.4

    Update tokio-uring to 0.4

    PR Type

    Dependency update

    PR Checklist

    • [ ] Tests for the changes have been added / updated.
    • [ ] Documentation comments have been added / updated.
    • [x] A changelog entry has been made for the appropriate packages.
    • [ ] Format code with the latest stable rustfmt.
    • [x] (Team) Label with affected crates and semver status.

    Overview

    update tokio-uring to 0.4

    A-files B-semver-minor A-web 
    opened by asonix 0
Releases(router-v0.5.1)
  • router-v0.5.1(Sep 19, 2022)

    • Fix typo in error string in Deserializer::deserialize_i32 implementation for Value. #2876
    • Minimum supported Rust version (MSRV) is now 1.59 due to transitive time dependency.
    Source code(tar.gz)
    Source code(zip)
  • web-v4.2.1(Sep 12, 2022)

  • web-v4.2.0(Sep 11, 2022)

    Added

    • Add #[routes] macro to support multiple paths for one handler. #2718
    • Add ServiceRequest::{parts, request}() getter methods. #2786
    • Add configuration options for TLS handshake timeout via HttpServer::{rustls, openssl}_with_config methods. #2752

    Changed

    • Minimum supported Rust version (MSRV) is now 1.59 due to transitive time dependency.
    Source code(tar.gz)
    Source code(zip)
  • http-v3.2.2(Sep 11, 2022)

    Changed

    • Minimum supported Rust version (MSRV) is now 1.59 due to transitive time dependency.

    Fixed

    • Avoid possibility of dispatcher getting stuck while back-pressuring I/O. #2369
    Source code(tar.gz)
    Source code(zip)
  • codegen-v4.1.0(Sep 11, 2022)

  • awc-v3.0.1(Aug 25, 2022)

    Changed

    • Minimum supported Rust version (MSRV) is now 1.57 due to transitive time dependency.

    Fixed

    • Fixed handling of redirection requests that begin with //. #2840
    Source code(tar.gz)
    Source code(zip)
  • test-v0.1.0(Jul 24, 2022)

  • http-v3.2.0(Jul 24, 2022)

    Changed

    • Minimum supported Rust version (MSRV) is now 1.57 due to transitive time dependency.

    Fixed

    • Websocket parser no longer throws endless overflow errors after receiving an oversized frame. #2790
    • Retain previously set Vary headers when using compression encoder. #2798
    Source code(tar.gz)
    Source code(zip)
  • http-test-v3.0.0(Jul 24, 2022)

  • files-v0.6.2(Jul 23, 2022)

    • Allow partial range responses for video content to start streaming sooner. #2817
    • Minimum supported Rust version (MSRV) is now 1.57 due to transitive time dependency.
    Source code(tar.gz)
    Source code(zip)
  • http-v3.2.1(Jul 2, 2022)

  • web-v4.1.0(Jun 11, 2022)

    Added

    • Add ServiceRequest::extract() to make it easier to use extractors when writing middlewares. #2647
    • Add Route::wrap() to allow individual routes to use middleware. #2725
    • Add ServiceConfig::default_service(). #2338 #2743
    • Implement ResponseError for std::convert::Infallible

    Changed

    • Minimum supported Rust version (MSRV) is now 1.56 due to transitive hashbrown dependency.

    Fixed

    • Clear connection-level data on HttpRequest drop. #2742
    Source code(tar.gz)
    Source code(zip)
  • http-v3.1.0(Jun 11, 2022)

    Changed

    • Minimum supported Rust version (MSRV) is now 1.56 due to transitive hashbrown dependency.

    Fixed

    • Revert broken fix in #2624 that caused erroneous 500 error responses. Temporarily re-introduces #2357 bug. #2779
    Source code(tar.gz)
    Source code(zip)
  • files-v0.6.1(Jun 11, 2022)

    • Add NamedFile::{modified, metadata, content_type, content_disposition, encoding}() getters. #2021
    • Update tokio-uring dependency to 0.3.
    • Audio files now use Content-Disposition: inline instead of attachment. #2645
    • Minimum supported Rust version (MSRV) is now 1.56 due to transitive hashbrown dependency.
    Source code(tar.gz)
    Source code(zip)
  • codegen-v4.0.1(Jun 11, 2022)

  • http-v3.0.4(Mar 9, 2022)

  • http-v3.0.3(Mar 8, 2022)

  • awc-v3.0.0(Mar 8, 2022)

    Dependencies

    • Updated actix-* to Tokio v1-based versions. #1813
    • Updated bytes to 1.0. #1813
    • Updated cookie to 0.16. #2555
    • Updated rand to 0.8.
    • Updated rustls to 0.20. #2414
    • Updated tokio to 1.

    Added

    • trust-dns crate feature to enable trust-dns-resolver as client DNS resolver; disabled by default. #1969
    • cookies crate feature; enabled by default. [#2619]
    • compress-brotli crate feature; enabled by default. #2250
    • compress-gzip crate feature; enabled by default. #2250
    • compress-zstd crate feature; enabled by default. #2250
    • client::Connector::handshake_timeout() for customizing TLS connection handshake timeout. #2081
    • client::ConnectorService as client::Connector::finish method's return type #2081
    • client::ConnectionIo trait alias #2081
    • Client::headers() to get default mut reference of HeaderMap of client object. #2114
    • ClientResponse::timeout() for set the timeout of collecting response body. #1931
    • ClientBuilder::local_address() for binding to a local IP address for this client. #2024
    • ClientRequest::insert_header() method which allows using typed and untyped headers. #1869
    • ClientRequest::append_header() method which allows using typed and untyped headers. #1869
    • ClientBuilder::add_default_header() (and deprecate ClientBuilder::header()). #2510

    Changed

    • client::Connector type now only has one generic type for actix_service::Service. #2063
    • client::error::ConnectError Resolver variant contains Box<dyn std::error::Error> type. #1905
    • client::ConnectorConfig default timeout changed to 5 seconds. #1905
    • ConnectorService type is renamed to BoxConnectorService. #2081
    • Fix http/https encoding when enabling compress feature. #2116
    • Rename TestResponse::{header => append_header, set => insert_header}. These methods now take a TryIntoHeaderPair. #2094
    • ClientBuilder::connector() method now takes Connector<T, U> type. #2008
    • Basic auth now accepts blank passwords as an empty string instead of an Option. #2050
    • Relax default timeout for Connector to 5 seconds (up from 1 second). #1905
    • *::send_json() and *::send_form() methods now receive impl Serialize. #2553
    • FrozenClientRequest::extra_header() now uses receives an impl TryIntoHeaderPair. #2553
    • Rename Connector::{ssl => openssl}(). #2503
    • ClientRequest::send_body now takes an impl MessageBody. #2546
    • Rename MessageBody => ResponseBody to avoid conflicts with MessageBody trait. #2546
    • Minimum supported Rust version (MSRV) is now 1.54.

    Fixed

    • Send headers along with redirected requests. #2310
    • Improve Client instantiation efficiency when using openssl by only building connectors once. #2503
    • Remove unnecessary Unpin bounds on *::send_stream. #2553
    • impl Future for ResponseBody no longer requires the body type be Unpin. #2546
    • impl Future for JsonBody no longer requires the body type be Unpin. #2546
    • impl Stream for ClientResponse no longer requires the body type be Unpin. #2546

    Removed

    • compress crate feature. #2250
    • ClientRequest::set; use ClientRequest::insert_header. #1869
    • ClientRequest::set_header; use ClientRequest::insert_header. #1869
    • ClientRequest::set_header_if_none; use ClientRequest::insert_header_if_none. #1869
    • ClientRequest::header; use ClientRequest::append_header. #1869
    • Deprecated methods on ClientRequest: if_true, if_some. #2148
    • ClientBuilder::default function #2008

    Security

    Source code(tar.gz)
    Source code(zip)
  • http-v3.0.2(Mar 5, 2022)

  • http-v3.0.1(Mar 4, 2022)

  • actors-v4.1.0(Mar 2, 2022)

  • web-v4.0.1(Feb 25, 2022)

  • web-v4.0.0(Feb 25, 2022)

  • multipart-v0.4.0(Feb 25, 2022)

  • http-v3.0.0(Feb 25, 2022)

  • files-v0.6.0(Feb 25, 2022)

  • codegen-v4.0.0(Feb 25, 2022)

  • codegen-v0.5.0(Feb 25, 2022)

  • actors-v4.0.0(Feb 25, 2022)

  • router-v0.5.0(Feb 22, 2022)

Owner
Actix
Actix - web and actor frameworks for Rust
Actix
Salvo is a powerful and simplest web server framework in Rust world

Salvo is an extremely simple and powerful Rust web backend framework. Only basic Rust knowledge is required to develop backend services.

Salvo 1.2k Jan 5, 2023
A starter template for actix-web projects that feels very Django-esque. Avoid the boring stuff and move faster.

Jelly A.K.A, the actix-web starter you probably wish you had. This is provided as-is, and anyone is free to extend it or rework it as they desire - ju

SecretKeys 198 Dec 15, 2022
Add Facebook and Google authentication to your HTTP REST API in Actix-web

I created this project while learning Rust. Project shows how to handle Facebook and Google token verification in Rust using Actix-Web. Hope this help

null 37 Dec 31, 2022
In-progress extractors and middleware for Actix Web

actix-web-lab Experimental extractors, middleware, and other extras for possible inclusion in Actix Web. Things To Know About This Crate It will never

Rob Ede 51 Dec 20, 2022
Example Blog using Rust, Actix Web, HTMX, Mustache

Actix Blog An example blog built with Actix. It uses htmx and handlebar templates. Running To run the blog, you need to have a recent version of Rust

Dru Jensen 2 Nov 11, 2022
Extension for actix-web to validate user permissions

actix-web-grants Extension for actix-web to validate user permissions. To check user access to specific services, you can use built-in proc-macro, Per

Artem Medvedev 114 Dec 22, 2022
Easy to use multipart forms for actix-web

Actix Easy Multipart Easy to use Multipart Forms for actix-web. File uploads are written to disk as temporary files similar to the way the $_FILES var

Jacob Halsey 17 Jan 3, 2023
Static Web Server - a very small and fast production-ready web server suitable to serve static web files or assets

Static Web Server (or SWS abbreviated) is a very small and fast production-ready web server suitable to serve static web files or assets.

Jose Quintana 496 Jan 2, 2023
Cookiecutter Rust Actix template for jumpstarting production-ready projects quickly.

Cookiecutter actix simple clean architecture This is a reusable Rust Cookiecutter template. The project is based on Actix web in combination with Dies

Microsoft 19 Feb 12, 2023
Example Actix 2.x REST application implementing many features

Rust/Actix Example An Actix 2.0 REST server using the Rust language. Motivation Actix Web is a fast, powerful web framework for building web applicati

David D. 238 Dec 31, 2022
Basic Actix + Diesel + Postgres REST API

Actix-Crud Basic Actix + Diesel + Postgres REST API Setup Install and setup PostgreSQL Set DATABASE_URL environment variable or specify in .env file g

Aathif Naseer 4 Sep 23, 2022
A fast, boilerplate free, web framework for Rust

Tower Web A web framework for Rust with a focus on removing boilerplate. API Documentation Tower Web is: Fast: Fully asynchronous, built on Tokio and

Carl Lerche 969 Dec 22, 2022
Sincere is a micro web framework for Rust(stable) based on hyper and multithreading

The project is no longer maintained! Sincere Sincere is a micro web framework for Rust(stable) based on hyper and multithreading. Style like koa. The

null 94 Oct 26, 2022
A flexible web framework that promotes stability, safety, security and speed.

A flexible web framework that promotes stability, safety, security and speed. Features Stability focused. All releases target stable Rust. This will n

Gotham 2.1k Jan 3, 2023
A toy web framework inspired by gin-gonic/gin and expressjs/express.

Rum Framework A toy web framework inspired by gin-gonic/gin and expressjs/express. Installation Just add rum_framework to the dependencies of Cargo.to

Hidetomo Kou(YingZhi 2 Dec 20, 2022
:zap: fast http framework for rust

zap ⚡ The mission of zap is, to deliver a basic, but fast rust web server library. Documentation About This code is based on tokio's minihttp project,

Daniel Oltmanns 51 Jun 7, 2022
An Extensible, Concurrent Web Framework for Rust

Iron Extensible, Concurrency Focused Web Development in Rust. Response Timer Example Note: This example works with the current iron code in this repos

null 6.1k Dec 27, 2022
An expressjs inspired web framework for Rust

nickel.rs nickel.rs is a simple and lightweight foundation for web applications written in Rust. Its API is inspired by the popular express framework

null 3k Jan 3, 2023
A web framework for Rust.

Rocket Rocket is an async web framework for Rust with a focus on usability, security, extensibility, and speed. #[macro_use] extern crate rocket; #[g

Sergio Benitez 19.5k Jan 8, 2023