Deploy your apps on any Cloud provider in just a few seconds

Overview

Qovery logo

The simplest way to deploy your apps in the Cloud

Deploy your apps on any Cloud providers in just a few seconds

work in progress badge Func tests Discord


Qovery stack on top of Kubernetes and Cloud providers

Qovery Engine is an open-source abstraction layer library that turns easy apps deployment on AWS, GCP, Azure, and other Cloud providers in just a few minutes. The Qovery Engine is written in Rust and takes advantage of Terraform, Helm, Kubectl, and Docker to manage resources.

Please note: We take Qovery's security and our users' trust very seriously. If you believe you have found a security issue in Qovery, please responsibly disclose by contacting us at [email protected].

Features

  • Zero infrastructure management: Qovery Engine initializes, configures, and manages your Cloud account for you.
  • Multi Cloud: Qovery Engine is built to work on AWS, GCP, Azure and any Cloud provider.
  • On top of Kubernetes: Qovery Engine takes advantage of the power of Kubernetes at a higher level of abstraction.
  • Terraform and Helm: Qovery Engine uses Terraform and Helm files to manage the infrastructure and app deployment.
  • Powerful CLI: Use the provided Qovery Engine CLI to deploy your app on your Cloud account seamlessly.
  • Web Interface: Qovery provides a web interface through qovery.com

🔌 Plugins

Qovery engine workflow

Qovery engine supports a number of different plugins to compose your own deployment flow:

See more on our website.

Demo

Here is a demo from Qovery CLI from where we use the Qovery Engine.

Qovery CLI

Getting Started

Installation

Use the Qovery Engine as a Cargo dependency.

qovery-engine = { git = "https://github.com/Qovery/engine", branch="main" }

Usage

Rust lib

Initialize EKS (AWS Kubernetes) and ECR (AWS container registry) on AWS

let engine = Engine::new(
    context, // parameters
    local_docker, // initialize Docker as a Build Platform
    ecr, // initialize Elastic Container Registry
    aws, // initialize AWS account
    cloudflare, // initialize Cloudflare as DNS Nameservers
);

let session = match engine.session() {
    Ok(session) => session, // get the session
    Err(config_error) => panic!("configuration error {:?}", config_error),
};

let mut tx = session.transaction();

// create EKS (AWS managed Kubernetes cluster)
tx.create_kubernetes(&eks);

// create the infrastructure and wait for the result
match tx.commit() { 
    TransactionResult::Ok => println!("OK"),
    TransactionResult::Rollback(commit_err) => println!("ERROR but rollback OK"), 
    TransactionResult::UnrecoverableError(commit_err, rollback_err) => println!("FATAL ERROR")
};

Deploy an app from a Github repository on AWS

// create a session before
//------------------------

let mut environment = Environment {...};

let app = Application {
    id: "app-id-1".to_string(),
    name: "app-name-1".to_string(),
    action: Action::Create, // create the application, you can also do other actions
    git_url: "https://github.com/Qovery/node-simple-example.git".to_string(),
    git_credentials: GitCredentials {
        login: "github-login".to_string(), // if the repository is a private one, then use credentials
        access_token: "github-access-token".to_string(),
        expired_at: Utc::now(), // it's provided by the Github API
    },
    branch: "main".to_string(),
    commit_id: "238f7f0454783defa4946613bc17ebbf4ccc514a".to_string(),
    dockerfile_path: "Dockerfile".to_string(),
    private_port: Some(3000),
    total_cpus: "1".to_string(),
    cpu_burst: "1.5".to_string(),
    total_ram_in_mib: 256,
    total_instances: 1,
    storage: vec![], // you can add persistent storage here
    environment_variables: vec![], // you can include env var here
};

// add the app to the environment that we want to deploy
environment.applications.push(app);

// open a transaction
let mut tx = session.transaction();

// request to deploy the environment
tx.deploy_environment(&EnvironmentAction::Environment(environment));

// commit and deploy the environment
tx.commit();

Note: the repository needs to have a Dockerfile at the root.

Documentation

Full, comprehensive documentation is available on the Qovery website: https://docs.qovery.com

Contributing

Please read our Contributing Guide before submitting a Pull Request to the project.

Community support

For general help using Qovery Engine, please refer to the official Qovery Engine documentation. For additional help, you can use one of these channels to ask a question:

  • Discord (For live discussion with the Community and Qovery team)
  • GitHub (Bug reports, Contributions)
  • Roadmap (Roadmap, Feature requests)
  • Twitter (Get the news fast)

Roadmap

Check out our roadmap to get informed of the latest features released and the upcoming ones. You may also give us insights and vote for a specific feature.

FAQ

Why does Qovery exist?

At Qovery, we believe that the Cloud must be simpler than what it is today. Our goal is to consolidate the Cloud ecosystem and makes it accessible to any developer, DevOps, and company. Qovery helps people to focus on what they build instead of wasting time doing plumbing stuff.

What is the difference between Qovery and Qovery Engine?

Qovery is a Container as a Service platform for developers. It combines the simplicity of Heroku, the reliability of AWS, and the power of Kubernetes. It makes the developer and DevOps life easier to deploy complex applications.

Qovery Engine is the Open Source abstraction layer used by Qovery to abstract the deployment of containers and databases on any Cloud provider.

Why is the Qovery Engine written in Rust?

Rust is underrated in the Cloud industry. At Qovery, we believe that Rust can help in building resilient, efficient, and performant products. Qovery wants to contribute to make Rust being a significant player in the Cloud industry for the next 10 years.

Why do you use Terraform, Helm and Kubectl binaries?

The Qovery Engine is designed to operate as an administrator and takes decisions on the output of binaries, service, API, etc. Qovery uses the most efficient tools available in the market to manage resources.

License

See the LICENSE file for licensing information.

Qovery

Qovery is a CNCF and Linux Foundation silver member.

CNCF Silver Member logo

Comments
  • Using native APIs instead of using command line interfaces of Terraform, Helm, Kubectl, and Docker [feature request]

    Using native APIs instead of using command line interfaces of Terraform, Helm, Kubectl, and Docker [feature request]

    Hi,

    I know, it's a goal of the project to get rid of using command line interfaces.

    After reading issue https://github.com/Qovery/engine/issues/25, I did some research, and I thought it would be useful to start this issue to collect relevant information, and to track progress.

    For kubectl u/garypen proposed kube.rs and k8s-openapi.

    For the other tools: Bindings most likely also would be useful to the ecosystems of other programming languages as well. Maybe a solution that's based on gRPC, WASM, or similar would make it easier to secure support from the maintainers of these tools?

    Basically, there would need to be a definition of the API (i.e. in JSON) and a gRPC server (or similar). New clients then could automatically generate the native API from the protocol definition (which would be almost trivial in Rust with serde).

    Go has experimental WASM support.

    Terraform already has a gRPC server for plugins, but I'm not sure if it could be used to implement a native API for what the command line tool does.

    Another approach would be to use different tools, that have better APIs.

    Here is a list of alternatives to Terraform, for example:

    https://en.wikipedia.org/wiki/Infrastructure_as_code#Tools

    Pulumi looks promising. They have already an SDK for TypeScript, JavaScript, Python, and Go, which they seem to have implemented via a gRPC server.

    Currently, no support for Rust is planned, but community contributed support would be welcome.

    I found the following resources that show how to implement an SDK for a new language:

    What do you guys think?

    I'd love to use Rust for my Infrastructure as Code needs, but using command line interfaces internally is a dealbreaker for me (and most likely for many other people, as well).

    enhancement question 
    opened by d4h0 4
  • [Enchancement] Consider a simple interpreter to reduce scope of shell exec

    [Enchancement] Consider a simple interpreter to reduce scope of shell exec

    After reading the code, there is a lot of files that are doing command wrapping by doing shell exec behind the scene. While doing shell exec is OK as reimplementing everything of what binaries are doing is

    • Tedious and error prone
    • Does not bring much value
    • Risk of breaking with different version

    A big chunk of the code is riddled with system exec with its own had hoc way of parsing output, calling convention and doing the same kind of operation.

    To centralize, standardize and isolate those system-exec, consider moving from raw Command::new to a simple interpreter. It will have the benefit of :

    • Output is a standardized json
    • Command only need to return a result per line and will be automatically turned into an array of string
    • Every system exec will happen behind a standard code interface
    • System exec will appear only once in the code, inside exec_shell
    • Avoid Command::new to creep more into the code
    • Ease the test of those function, only need to check script output

    Please find below an example of working interpreter. It can still be improved (timeout can be added, be safer) but provide enough flexibility IMHO.

    // Operations available for our shell support
    pub enum Shell<'a> {
        ExecCmd(&'a str, &'a str),
        ExecCmdWithRetry(&'a str, &'a str, u32),
        EnsureCmd(&'a str),
        SetEnv(&'a str, &'a str),
        SetEnvs(&'a Vec<(&'a str, &'a str)>),
    
    }
    
    // Standardized output for all our shell command, a script output is just a Vec<ShellOutput>
    #[derive(Deserialize, Debug)]
    pub struct ShellOutput {
        name: String,
        command: String,
        error: String,
        values: Vec<String>
    }
    
    // Snippet of shell script that exec a command and format it's output to a json file "ret.json"
    pub fn cmd_output_to_json(name: &str, cmd: &str) -> String {
        format!(r#"
    ##################
    # {0}
    ##################
    {1} > ret.stdout 2> ret.stderr
    cmd_exit_code=$?
    echo '{{ "name": "{0}",' >> ret.json
    echo '   "command": "{1}",' >> ret.json
    echo '   "error": "'$(cat ret.stderr | tr "\"" "'")'",' >> ret.json
    echo '   "values": ['$(cat ret.stdout | xargs -n1 -I R echo '"R"' | paste -sd ',')']' >> ret.json
    echo '}}' >> ret.json
    echo ',' >> ret.json
    
    [[ $cmd_exit_code -eq 0 ]] || exit 1
    "#, name, cmd)
    }
    
    // Exec a command with nb max retry
    pub fn retry(name: &str, cmd: &str, max_retry: u32) -> String {
        format!(r#"
    ##################
    # RETRY {2} - {0}
    ##################
    COUNTER=0
    cmd_exit_code=0
    while [  $COUNTER -lt {2} ]; do
        let COUNTER=COUNTER+1
        {1} > ret.stdout 2> ret.stderr
        cmd_exit_code=$?
        [[ $cmd_exit_code -eq 0 ]] && break
        sleep 2
    done
    
    echo '{{ "name": "{0}",' >> ret.json
    echo '   "command": "{1}",' >> ret.json
    echo '   "error": "'$(cat ret.stderr | tr "\"" "'")'",' >> ret.json
    echo '   "values": ['$(cat ret.stdout | xargs -n1 -I R echo '"R"' | paste -sd ',')']' >> ret.json
    echo '}}' >> ret.json
    echo ',' >> ret.json
    
    [[ $cmd_exit_code -eq 0 ]] || exit 1
    "#, name, cmd, max_retry)
    }
    
    // Transform operation/opcode of our shell into real sh script
    fn eval_opcode(action: &Shell, builder: &mut String) {
        match action {
            Shell::ExecCmd(name, args)=> {
                builder.push_str(cmd_output_to_json(name, args).as_str());
            },
            Shell::SetEnv(name, value) => {
                builder.push_str(format!("export {}=\"{}\"\n", name, value).as_str());
            }
            Shell::SetEnvs(envs ) => {
                for (name, value) in envs.iter() {
                    builder.push_str(format!("export {}=\"{}\"\n", name, value).as_str());
                }
            }
            Shell::ExecCmdWithRetry(name, cmd, max_retry) => {
                builder.push_str(retry(name, cmd, *max_retry).as_str());
            }
            Shell::EnsureCmd(cmd) => {
                eval_opcode(&Shell::ExecCmd(format!("ensure command {}", cmd).as_str(),
                                            format!("command -v {}", cmd).as_str()),
                            builder)
            }
        };
    }
    
    // Generate a complete/executable shell script from our Shell Opcode
    pub fn generate_shell(actions: &Vec<Shell>) -> String {
    
        let mut builder = String::with_capacity(1024);
        builder.push_str("#!/bin/sh
    echo '[' >> ret.json
    trap \"rm ret.stdout; rm ret.stderr; sed -i '$ d' ret.json ; echo ']' >> ret.json\" EXIT
        ");
    
        for cmd in vec![EnsureCmd("cat"), EnsureCmd("sed"), EnsureCmd("paste")] {
            eval_opcode(&cmd, &mut builder);
        }
        for cmd in actions {
            eval_opcode(&cmd, &mut builder);
        }
    
        builder
    }
    
    // Execute our shell script
    // 1. Generate the shell script and write it into a temporary folder
    // 2. Execute the script with a Command/system exec
    // 3. Use serde to parse standard json and extract its value
    pub fn exec_shell<P: FromStr>(actions: &Vec<Shell>) -> Result<P, SimpleError> 
    {
        use std::fs::File;
        use tempfile::tempdir;
    
        // Generate and write our shell script into a tmp dir (cleaned when variable is droped)
        let dir = tempdir()?;
        let mut script_path = dir.path().join("run.sh");
        File::create(&script_path)?
            .write_all(generate_shell(&actions).into_bytes().as_slice());
    
        // Exec our script
        let exit = Command::new("sh")
            .arg(&script_path)
            .current_dir(dir.path())
            .output()?;
    
        // Parse ret.json to extract value of the commands
        let return_file = File::open(dir.path().join("ret.json"))?;
        let results: Vec<ShellOutput> = serde_json::from_reader(BufReader::new(return_file))?;
    
      // Check run success when empty json
      // Can be turned into None/Option to simplify
        if exit.status.success() && results.is_empty() {
            return P::from_str("").or_else(|err| {
                Err(SimpleError{
                    kind: SimpleErrorKind::Other,
                    message: Some(format!("Cannot parse string to correct format"))
                })
            });
        }
    
        if !exit.status.success() && results.is_empty() {
            return Err(SimpleError{
                kind: SimpleErrorKind::Command(exit.status),
                message: Some(format!("Error executing command: {:?}", exit.stderr))
            });
        }
    
        // Standard case
        for result in results.iter().rev() {
            if !result.error.is_empty() {
                return Err(SimpleError{
                    kind: SimpleErrorKind::Command(exit.status),
                    message: Some(format!("Error executing command: {:?}", result))
                });
            }
        }
    
        P::from_str(results.last().unwrap().values.join("").as_str()).or_else( |err|
            Err(SimpleError{
                kind: SimpleErrorKind::Other,
                message: Some(format!("Cannot parse string to correct format"))
            })
        )
    
    }
    
    #[cfg(test)]
    mod tests {
        use crate::cmd::kubectl::Shell::{ExecCmd, ExecCmdWithRetry, EnsureCmd, SetEnv};
        use crate::cmd::kubectl::{generate_shell, exec_shell};
    
        #[test]
        fn test_generate_shell() {
            let actions = vec![
                EnsureCmd("kubectl"), EnsureCmd("docker"),
                SetEnv("KUBECONFIG", "/home/erebe/.kube/config"),
                ExecCmd("get pod number of restart", "kubectl get pods -o=custom-columns=:.status.containerStatuses..restartCount --no-headers=true"),
                ExecCmdWithRetry("list lol", "kubectl get lol", 3),
            ];
    
            //let script = generate_shell(&actions);
            //println!("{}", script);
    
            let ret = exec_shell::<String>(&actions);
            println!("{:?}", ret);
        }
    
    }
    

    It generates script like below

    #!/bin/sh
    echo '[' >> ret.json
    trap "rm ret.stdout; rm ret.stderr; sed -i '$ d' ret.json ; echo ']' >> ret.json" EXIT
    
    ##################
    # ensure command cat
    ##################
    command -v cat > ret.stdout 2> ret.stderr
    cmd_exit_code=$?
    echo '{ "name": "ensure command cat",' >> ret.json
    echo '   "command": "command -v cat",' >> ret.json
    echo '   "error": "'$(cat ret.stderr | tr "\"" "'")'",' >> ret.json
    echo '   "values": ['$(cat ret.stdout | xargs -n1 -I R echo '"R"' | paste -sd ',')']' >> ret.json
    echo '}' >> ret.json
    echo ',' >> ret.json
    
    [[ $cmd_exit_code -eq 0 ]] || exit 1
    
    ...
    

    With ret.json file looking like

    [
    { "name": "ensure command cat",
       "command": "command -v cat",
       "error": "",
       "values": ["/usr/bin/cat"]
    }
    ,
    { "name": "ensure command sed",
       "command": "command -v sed",
       "error": "",
       "values": ["/usr/bin/sed"]
    }
    ,
    { "name": "ensure command paste",
       "command": "command -v paste",
       "error": "",
       "values": ["/usr/bin/paste"]
    }
    ,
    { "name": "ensure command kubectl",
       "command": "command -v kubectl",
       "error": "",
       "values": ["/usr/bin/kubectl"]
    }
    ,
    { "name": "ensure command docker",
       "command": "command -v docker",
       "error": "",
       "values": ["/usr/bin/docker"]
    }
    ,
    { "name": "get pod number of restart",
       "command": "kubectl get pods -o=custom-columns=:.status.containerStatuses..restartCount --no-headers=true",
       "error": "",
       "values": ["0","0","0","0","0","1","0","0"]
    }
    ,
    { "name": "list lol",
       "command": "kubectl get lol",
       "error": "error: the server doesn't have a resource type 'lol'",
       "values": []
    }
    ]
    

    As an example, 2 kubectl commands rewrote with this simple interpreter

    pub fn kubectl_exec_get_number_of_restart(
        kubernetes_config: &str,
        namespace: &str,
        podname: &str,
        envs: &Vec<(&str, &str)>,
    ) -> Result<String, SimpleError> {
        let cmd_str = format!("get pods {} -n {} -o=custom-columns=:.status.containerStatuses..restartCount --no-headers=true", podname, namespace);
        let cmd = vec![
            EnsureCmd("kubectl"),
            SetEnv(KUBECONFIG, kubernetes_config),
            SetEnvs(&envs),
            ExecCmd("pod nb of restart", cmd_str.as_str())
        ];
    
       exec_shell(&cmd)
    }
    
    
    pub fn kubectl_exec_get_external_ingress_hostnamel(
        kubernetes_config: &str,
        namespace: &str,
        selector: &str,
        envs: &Vec<(&str, &str)>,
    ) -> Result<String, SimpleError>
    {
        let cmd_str = format!("get svc -o json -n {} -l {}", namespace, selector);
        let cmd = vec![
            EnsureCmd("kubectl"),
            SetEnv(KUBECONFIG, kubernetes_config),
            SetEnvs(&envs),
            ExecCmd("get external ingress hostname", cmd_str.as_str())
        ];
    
        exec_shell(&cmd)
    }
    
    // Do the same for terraform, docker, etc...
    
    enhancement 
    opened by erebe 4
  • Force deployment restart on helm upgrade

    Force deployment restart on helm upgrade

    • In order to implement restart, we want to force rollout even if nothing changes in the deployment
    • CREATE action should be renamed DEPLOY to be more insightfull
    opened by erebe 3
  • Feat/infra pause

    Feat/infra pause

    This PR enables infra pause for AWS:

    • Pause will destroy nodes group
    • Restore will re-run deploy to get everything deployed
    • Updated pod policy to critical elements to ensure they will be correctly restored and prioritized
    • Added prometheus adapter to support custom metrics and report the to k8s API
    • Checking no jobs are running on the engine before starting pause using custom metrics api
    • Refactored terraform force upgrade hack to speed up re-deployments
    opened by deimosfr 3
  • build(deps): bump thread_local from 1.0.1 to 1.1.4 in /test_utilities

    build(deps): bump thread_local from 1.0.1 to 1.1.4 in /test_utilities

    Bumps thread_local from 1.0.1 to 1.1.4.

    Commits
    • 4a54e57 Bump version to 1.1.4
    • ebf8b45 Merge pull request #34 from ibraheemdev/patch-1
    • 3d69afa Fix memory ordering in RawIter::next
    • c7d8dcd Bump version to 1.1.3
    • 5e8bbf2 Merge pull request #30 from Marwes/fix_drop
    • a44b836 fix: Drop the value in the ThreadLocal on drop
    • 322cf34 Bump version to 1.1.2
    • dca4007 Merge pull request #29 from Kestrer/raw-iter
    • 33ad405 Add #[inline] to non-generic functions
    • 810c043 Implement iterator logic in RawIter
    • Additional commits viewable in compare view

    Dependabot compatibility score

    Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.


    Dependabot commands and options

    You can trigger Dependabot actions by commenting on this PR:

    • @dependabot rebase will rebase this PR
    • @dependabot recreate will recreate this PR, overwriting any edits that have been made to it
    • @dependabot merge will merge this PR after your CI passes on it
    • @dependabot squash and merge will squash and merge this PR after your CI passes on it
    • @dependabot cancel merge will cancel a previously requested merge and block automerging
    • @dependabot reopen will reopen this PR if it is closed
    • @dependabot close will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
    • @dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
    • @dependabot use these labels will set the current labels as the default for future PRs for this repo and language
    • @dependabot use these reviewers will set the current reviewers as the default for future PRs for this repo and language
    • @dependabot use these assignees will set the current assignees as the default for future PRs for this repo and language
    • @dependabot use this milestone will set the current milestone as the default for future PRs for this repo and language

    You can disable automated security fix PRs for this repo from the Security Alerts page.

    dependencies 
    opened by dependabot[bot] 2
  • build(deps): bump smallvec from 0.6.13 to 0.6.14 in /test_utilities

    build(deps): bump smallvec from 0.6.13 to 0.6.14 in /test_utilities

    Bumps smallvec from 0.6.13 to 0.6.14.

    Release notes

    Sourced from smallvec's releases.

    v0.6.14

    • Fix a possible buffer overflow in insert_many (#252, #254).
    Commits

    Dependabot compatibility score

    Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.


    Dependabot commands and options

    You can trigger Dependabot actions by commenting on this PR:

    • @dependabot rebase will rebase this PR
    • @dependabot recreate will recreate this PR, overwriting any edits that have been made to it
    • @dependabot merge will merge this PR after your CI passes on it
    • @dependabot squash and merge will squash and merge this PR after your CI passes on it
    • @dependabot cancel merge will cancel a previously requested merge and block automerging
    • @dependabot reopen will reopen this PR if it is closed
    • @dependabot close will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
    • @dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
    • @dependabot use these labels will set the current labels as the default for future PRs for this repo and language
    • @dependabot use these reviewers will set the current reviewers as the default for future PRs for this repo and language
    • @dependabot use these assignees will set the current assignees as the default for future PRs for this repo and language
    • @dependabot use this milestone will set the current milestone as the default for future PRs for this repo and language

    You can disable automated security fix PRs for this repo from the Security Alerts page.

    dependencies 
    opened by dependabot[bot] 2
  • Postgres Connection URL not compatible with Python database drivers.

    Postgres Connection URL not compatible with Python database drivers.

    I wanted to create a database in Qovery. I grabbed the db_url from the UI.

    DB_URL = "postgresql://postgres:_Ij=de-6S8B$avgXtFN?@[email protected]:5432/postgres" (Don't worry, this database does not exist in Qovery anymore.)

    I'm getting an error.

    File "/home/harshitsinghai/.pyenv/versions/3.9.5/lib/python3.9/urllib/parse.py", line 178, in port
        raise ValueError(message) from None
    ValueError: Port could not be cast to integer value as '_Ij=de-6S8B$avgXtFN'
    

    I deleted the database, created a new one, and tried again with the new db_url. But I'm getting the same error.

    I don't think using postgres as the default DB username is a good idea. It will be confused by many URL parsers.

    postgresql://postgres:U8T%2T#YjO#-ep-MjGBcJ_ this string might be creating confusion for lots of parsers.

    Either give the user the option to change the default username or use something more generic.

    Code Snippet

    QOVERY_URL = "postgresql://postgres:U8T%2T#YjO#-ep-MjGBcJ_@!fgczi!%[email protected]:5432/postgres"
    database = databases.Database(QOVERY_URL)
    metadata = sqlalchemy.MetaData()
    
    engine = sqlalchemy.create_engine(QOVERY_URL)
    
    opened by harshitsinghai77 2
  • Enable publish service for nginx-ingress

    Enable publish service for nginx-ingress

    By enabling this option the controller is going to use a service to know the ingress endpoint/address to use. In our case, it is going to pick the LB hostname thus it is going to avoid the need to add on every ingress target annotation for external DNS with the LB hostname. This reduce the toil to update LB endpoint when it changes, as it is done automatically now

    opened by erebe 2
  • Add support for mono-repo with multiple build context

    Add support for mono-repo with multiple build context

    • Change to support mono-repo, aka being able to build image from other directory than the root of the repository.

    • Fix: Don't try to use buildkit if the specified Dockerfile is not present in the repository

    opened by erebe 2
  • Document huawei cloud support

    Document huawei cloud support

    In my experience Huawei cloud is pretty similar to S3 (though occasionally some things are just ever so slightly different). It would be nice if huawei cloud could be tested and added to the readme if it works. Just because it's probably the most popular cloud provider in china

    opened by xd009642 2
  • build(deps): bump regex from 1.5.4 to 1.5.5

    build(deps): bump regex from 1.5.4 to 1.5.5

    Bumps regex from 1.5.4 to 1.5.5.

    Changelog

    Sourced from regex's changelog.

    1.5.5 (2022-03-08)

    This releases fixes a security bug in the regex compiler. This bug permits a vector for a denial-of-service attack in cases where the regex being compiled is untrusted. There are no known problems where the regex is itself trusted, including in cases of untrusted haystacks.

    Commits

    Dependabot compatibility score

    Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.


    Dependabot commands and options

    You can trigger Dependabot actions by commenting on this PR:

    • @dependabot rebase will rebase this PR
    • @dependabot recreate will recreate this PR, overwriting any edits that have been made to it
    • @dependabot merge will merge this PR after your CI passes on it
    • @dependabot squash and merge will squash and merge this PR after your CI passes on it
    • @dependabot cancel merge will cancel a previously requested merge and block automerging
    • @dependabot reopen will reopen this PR if it is closed
    • @dependabot close will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
    • @dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
    • @dependabot use these labels will set the current labels as the default for future PRs for this repo and language
    • @dependabot use these reviewers will set the current reviewers as the default for future PRs for this repo and language
    • @dependabot use these assignees will set the current assignees as the default for future PRs for this repo and language
    • @dependabot use this milestone will set the current milestone as the default for future PRs for this repo and language

    You can disable automated security fix PRs for this repo from the Security Alerts page.

    dependencies 
    opened by dependabot[bot] 1
  • Bump lock_api from 0.3.4 to 0.4.7

    Bump lock_api from 0.3.4 to 0.4.7

    Bumps lock_api from 0.3.4 to 0.4.7.

    Changelog

    Sourced from lock_api's changelog.

    parking_lot_core 0.9.2, lock_api 0.4.7 (2022-03-25)

    • Enable const new() on lock types on stable. (#325)
    • Added MutexGuard::leak function. (#333)
    • Bump windows-sys dependency to 0.34. (#331)
    • Bump petgraph dependency to 0.6. (#326)
    • Don't use pthread attributes on the espidf platform. (#319)

    parking_lot_core 0.9.1 (2022-02-06)

    • Bump windows-sys dependency to 0.32. (#316)

    parking_lot 0.12.0, parking_lot_core 0.9.0, lock_api 0.4.6 (2022-01-28)

    • The MSRV is bumped to 1.49.0.
    • Disabled eventual fairness on wasm32-unknown-unknown. (#302)
    • Added a rwlock method to report if lock is held exclusively. (#303)
    • Use new asm! macro. (#304)
    • Use windows-rs instead of winapi for faster builds. (#311)
    • Moved hardware lock elision support to a separate Cargo feature. (#313)
    • Removed used of deprecated spin_loop_hint. (#314)

    parking_lot 0.11.2, parking_lot_core 0.8.4, lock_api 0.4.5 (2021-08-28)

    • Fixed incorrect memory orderings on RwLock and WordLock. (#294, #292)
    • Added Arc-based lock guards. (#291)
    • Added workaround for TSan's lack of support for fence. (#292)

    lock_api 0.4.4 (2021-05-01)

    • Update for latest nightly. (#281)

    lock_api 0.4.3 (2021-04-03)

    • Added [Raw]ReentrantMutex::is_owned. (#280)

    parking_lot_core 0.8.3 (2021-02-12)

    • Updated smallvec to 1.6. (#276)

    parking_lot_core 0.8.2 (2020-12-21)

    • Fixed assertion failure on OpenBSD. (#270)

    parking_lot_core 0.8.1 (2020-12-04)

    • Removed deprecated CloudABI support. (#263)
    • Fixed build on wasm32-unknown-unknown. (#265)
    • Relaxed dependency on smallvec. (#266)

    ... (truncated)

    Commits
    • 4160edf Release lock_api 0.4.7
    • 716bffb Merge pull request #334 from peterthejohnston/master
    • 1b7e91e Merge pull request #333 from Freax13/add-mutex-guard-leak
    • ff17324 Release parking_lot_core 0.9.2
    • 86b7815 add MutexGuard::leak
    • e27f37d Merge pull request #331 from peterthejohnston/patch-1
    • 68990ab Update windows-sys to v0.34.0
    • 217248f Merge pull request #325 from taiki-e/const_fn_trait_bound
    • cbab7b0 Update to stabilized const_fn_trait_bound
    • d7e4afd Merge pull request #326 from taiki-e/deps
    • Additional commits viewable in compare view

    Dependabot compatibility score

    Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.


    Dependabot commands and options

    You can trigger Dependabot actions by commenting on this PR:

    • @dependabot rebase will rebase this PR
    • @dependabot recreate will recreate this PR, overwriting any edits that have been made to it
    • @dependabot merge will merge this PR after your CI passes on it
    • @dependabot squash and merge will squash and merge this PR after your CI passes on it
    • @dependabot cancel merge will cancel a previously requested merge and block automerging
    • @dependabot reopen will reopen this PR if it is closed
    • @dependabot close will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
    • @dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
    • @dependabot use these labels will set the current labels as the default for future PRs for this repo and language
    • @dependabot use these reviewers will set the current reviewers as the default for future PRs for this repo and language
    • @dependabot use these assignees will set the current assignees as the default for future PRs for this repo and language
    • @dependabot use this milestone will set the current milestone as the default for future PRs for this repo and language

    You can disable automated security fix PRs for this repo from the Security Alerts page.

    dependencies 
    opened by dependabot[bot] 0
  • Readme: Azure vote link down

    Readme: Azure vote link down

    In the readme the vote link for the Azure cloud (https://github.com/Qovery/engine/blob/dev/README.md?plain=1#L45) is down. It leads to https://hub.qovery.com/docs/using-qovery/configuration/cloud-service-provider/azure/ which throws a 404

    opened by michidk 0
  • Why does the readme say you support certain cloud providers even though you don't?

    Why does the readme say you support certain cloud providers even though you don't?

    The readme says that you support AWS, Digital Ocean, Azure, GCP and Scaleway. But as I can see it only AWS and Digital Ocean are supported currently? Why are the others also listed under that heading? Same with Build Platforms, Container registries and Monitoring services. This is really confusing when you try to understand if this piece of software is something I'd be interested in using.

    opened by pitoriex 5
  • Feature request - qovery deploy button

    Feature request - qovery deploy button

    It seems that Qovery is heavily inspired by heroku among other things.

    I was wondering if Qovery already has a feature similar to heroku-button? And if not, that it would be considered as a new feature.

    opened by audiBookning 0
  • “Select a repo” don’t list the repository I want to use

    “Select a repo” don’t list the repository I want to use

    Issues information

    • OS: Linux
    • databases: No
    • Programming language and version: Python 3.X
    • Link to your project on Github/Gitlab: https://github.com/diagrams-web/diagrams-web

    Your issue

    The list of repositories fetched are not correct with multiple organizations.

    Describe here your issue

    To prevent duplication and maybe misunderstood please refer to the following thread:

    https://community.qovery.com/t/select-a-repo-dont-list-the-repositorie-i-want-to-use/140

    I'm not sure if it's the right place to open this issue so feel free to close it or move it to another repository.

    Thanks again for the fast reply and support!

    opened by gabriel-tessier 0
Owner
Qovery
Qovery - The simplest way to deploy your apps in the Cloud
Qovery
A Discord Server Cloner Which Can Clone Any Discord Server In Just Few Minutes

A Discord Server Cloner Which Can Clone Any Discord Server In Just Few Minutes.

samet 4 Jul 23, 2022
ShadowClone allows you to distribute your long running tasks dynamically across thousands of serverless functions and gives you the results within seconds where it would have taken hours to complete

ShadowClone allows you to distribute your long running tasks dynamically across thousands of serverless functions and gives you the results within seconds where it would have taken hours to complete

null 240 Jan 6, 2023
Crypto Signal Provider - A web application that allows users to select a cryptocurrency

Crypto_Signal_Provider This is a web application that allows users to select a c

Raul 2 Dec 11, 2022
Sail is a free CLI tool to deploy, manage and scale WordPress applications in the DigitalOcean cloud.

Deploy WordPress to DigitalOcean with Sail Sail is a free CLI tool to deploy, manage and scale WordPress applications in the DigitalOcean cloud. Conte

Konstantin Kovshenin 159 Dec 12, 2022
Develop and deploy applications with the Ionburst Cloud Python SDK.

Ionburst SDK for Python The Ionburst SDK for Python enables developers to easily integrate with Ionburst Cloud, building in ultra-secure and private o

Ionburst Cloud 3 Mar 6, 2022
A GUI Application that creates a Spotify Playlist from any year in the past, by just entering your preferred date

A GUI Application that creates a Spotify Playlist from any year in the past, by just entering your preferred date

David .K. Danso 1 Jan 17, 2022
Defi PancakeSwap bot is programmed in Python to buy and sell tokens in seconds once the target is hit.

Defi PancakeSwap BOT A BOT that will make easy your life in Trading. Watch tutorial on Youtube Table of Contents About The Project Built With Getting

Zain Ullah 208 Jan 5, 2023
Change the discord status throught websocket every 5 seconds with an insult

Discord status insult changer Change the discord status throught websocket every 5 seconds with an insult! - pip install httpx - put your tokens in "t

Ѵιcнч 10 Oct 27, 2022
A smart tool to backup members 📈 So you even after a raid/ ban you can easily restore them in seconds 🎲

?? Discord-backer ?? A open-source Discord member backup and restore tool for your server. This can help you get all your members in 5 Seconds back af

John 29 Dec 21, 2022
AirDrive lets you store unlimited files to cloud for free. Upload & download files from your personal drive at any time using its super-fast API.

AirDrive lets you store unlimited files to cloud for free. Upload & download files from your personal drive at any time using its super-fast API.

Sougata 4 Jul 12, 2022
Cloud-native, data onboarding architecture for the Google Cloud Public Datasets program

Public Datasets Pipelines Cloud-native, data pipeline architecture for onboarding datasets to the Google Cloud Public Datasets Program. Overview Requi

Google Cloud Platform 109 Dec 30, 2022
Prisma Cloud utility scripts, and a Python SDK for Prisma Cloud APIs.

pcs-toolbox Prisma Cloud utility scripts, and a Python SDK for Prisma Cloud APIs. Table of Contents Support Setup Configuration Script Usage CSPM Scri

Palo Alto Networks 34 Dec 15, 2022
Python client for using Prefect Cloud with Saturn Cloud

prefect-saturn prefect-saturn is a Python package that makes it easy to run Prefect Cloud flows on a Dask cluster with Saturn Cloud. For a detailed tu

Saturn Cloud 15 Dec 7, 2022
Cedric Owens 16 Sep 27, 2022
Davide Gallitelli 3 Dec 21, 2021
SmsSender v3.0.0 - the script is designed to send free SMS to any number and with any text.

SmsSender v3.0.0 - скрипт предназначен для бесплатной отправки SMS на любой номер и с любым текстом. Возможны небольшие баги, в скором времени исправл

Андрей Сергеев 20 Dec 3, 2021
Official Python client for the MonkeyLearn API. Build and consume machine learning models for language processing from your Python apps.

MonkeyLearn API for Python Official Python client for the MonkeyLearn API. Build and run machine learning models for language processing from your Pyt

MonkeyLearn 157 Nov 22, 2022
Light weight Scripts and Apps for checking availability of Covid Vaccines in India. Notifies when vaccine becomes avialable in your area.

vaccine-checker Light weight Scripts and Apps for checking availability of Covid Vaccines in India. Notifies when vaccine becomes avialable in your ar

Abishek V Ashok 8 Jun 16, 2021
Monetize your apps with KivAds using Google AdMob api.

KivAds(WIP) Monetize your apps with KivAds using Google AdMob api. KivAds uses the latest version of Google AdMob sdk(version 20.0.0). KivAds exposes

Guhan Sensam 16 Nov 5, 2022