Andre Fisher

Andre Fisher

1658979660

Web3: Ethereum JSON-RPC Multi-transport Client with Rust

web3

Ethereum JSON-RPC multi-transport client. Rust implementation of Web3.js library.

Documentation: crates.io

Usage

First, add this to your Cargo.toml:

[dependencies]
web3 = "0.17.0"

Example

#[tokio::main]
async fn main() -> web3::Result<()> {
    let transport = web3::transports::Http::new("http://localhost:8545")?;
    let web3 = web3::Web3::new(transport);

    println!("Calling accounts.");
    let mut accounts = web3.eth().accounts().await?;
    println!("Accounts: {:?}", accounts);
    accounts.push("00a329c0648769a73afac7f9381e08fb43dbea72".parse().unwrap());

    println!("Calling balance.");
    for account in accounts {
        let balance = web3.eth().balance(account, None).await?;
        println!("Balance of {:?}: {}", account, balance);
    }

    Ok(())
}

If you want to deploy smart contracts you have written you can do something like this (make sure you have the solidity compiler installed):

solc -o build --bin --abi contracts/*.sol

The solidity compiler is generating the binary and abi code for the smart contracts in a directory called contracts and is being output to a directory called build.

For more see examples folder.

Futures migration

  •  Get rid of parking_lot (replace with async-aware locks if really needed).
  •  Consider getting rid of Unpin requirements. (#361)
  •  WebSockets: TLS support (#360)
  •  WebSockets: Reconnecting & Pings
  •  Consider using tokio instead of async-std for ws.rs transport (issue with test).
  •  Restore IPC Transport

General

  •  More flexible API (accept Into<X>)
  •  Contract calls (ABI encoding; debris/ethabi)
  •  Batch Requests

Transports

  •  HTTP transport
  •  IPC transport
  •  WebSockets transport

Types

  •  Types for U256,H256,Address(H160)
  •  Index type (numeric, encoded to hex)
  •  Transaction type (Transaction from Parity)
  •  Transaction receipt type (TransactionReceipt from Parity)
  •  Block type (RichBlock from Parity)
  •  Work type (Work from Parity)
  •  Syncing type (SyncStats from Parity)

APIs

  •  Eth: eth_*
  •  Eth filters: eth_*
  •  Eth pubsub: eth_*
  •  net_*
  •  web3_*
  •  personal_*
  •  traces_*

Parity-specific APIs

 Parity read-only: parity_*

 Parity accounts: parity_* (partially implemented)

 Parity set: parity_*

 signer_*

 Own APIs (Extendable)

let web3 = Web3::new(transport);
web3.api::<CustomNamespace>().custom_method().wait().unwrap()

Installation on Windows

Currently, Windows does not support IPC, which is enabled in the library by default. To compile, you need to disable the IPC feature:

web3 = { version = "0.17.0", default-features = false, features = ["http"] }

Avoiding OpenSSL dependency

On Linux, native-tls is implemented using OpenSSL. To avoid that dependency for HTTPS use the corresponding feature.

web3 = { version = "0.17.0", default-features = false, features = ["http-rustls-tls"] }

Cargo Features

The library supports following features:

  • http - Enables HTTP transport (requires tokio runtime, because of hyper).
  • http-tls - Enables TLS support via reqwest/default-tls for HTTP transport (implies http; default).
  • http-native-tls - Enables TLS support via reqwest/native-tls for HTTP transport (implies http).
  • http-rustls-tls - Enables TLS support via reqwest/rustls-tls for HTTP transport (implies http).
  • ws-tokio - Enables WS transport using tokio runtime.
  • ws-tls-tokio - Enables TLS support for WS transport (implies ws-tokio; default).
  • ws-async-std - Enables WS transport using async-std runtime.
  • ws-tls-async-std - Enables TLS support for WS transport (implies ws-async-std).
  • ipc-tokio - Enables IPC transport using tokio runtime (default).
  • signing - Enable account namespace and local-signing support (default).
  • eip-1193 - Enable EIP-1193 support.
  • wasm - Compile for WASM (make sure to disable default features).
  • arbitrary_precision - Enable arbitrary_precision in serde_json.

Author: simonjiao
Source code: https://github.com/simonjiao/findora-agentd
License: MIT license

#rust #web3 

What is GEEK

Buddha Community

Web3: Ethereum JSON-RPC Multi-transport Client with Rust
Jack Shaw

Jack Shaw

1672986240

A Curated List Of Awesome Ethereum Ressources

A curated list of awesome Ethereum Ressources. Inspired by awesome-go.

Contributing

Please take a quick gander at the contribution guidelines first. Thanks to all contributors; you rock!

If you see a link or project here that is no longer maintained or is not a good fit, please submit a pull request to improve this file. Thank you!

Basic {#basic}

What is Ethereum? {#what-is-ethereum}

Bitcoin 2.0? a world computer? a smart contracts platform?

Papers {#papers}

If you feel like going to the source

Roadmap {#roadmap}

  • Timeline - Expected timeline - Post from Mars 2015.
    • Olympic - 0: Olympic.
    • Frontier - 1: Frontier.
    • Homestead - 2: Homestead <----- HERE WE ARE.
    • Metropolis - 3: Metropolis - "when we finally officially release a relatively full-featured user interface for non-technical users of Ethereum"
    • Serenity - 4: Serenity - Switching the network from Proof of Work to Proof of Stake ( Casper). end of 2016?.

Branding / Logo {#branding}

Crowfunding {#crowfunding}

Remembering a time where the price of Ether was 2000 ETH per BTC

Foundation {#foundation}

The Ethereum Foundation’s mission is to promote and support research, development and education to bring decentralized protocols and tools to the world that empower developers to produce next generation decentralized applications (DAPPs), and together build a more globally accessible, more free and more trustworthy Internet.

  • Website - The Ethereum foundation Page.

Clients {#clients}

Implementations of the Ethereum protocol.

The Ethereum network {#network}

Network Stat {#network-stats}

Need information about a block, a current difficulty, the network hashrate?

  • Ethstats - See latest data of the Ethereum Network.

Blockhain Explorer {#blockchain-explorer}

Mainnet

Testnet

Ether {#ether}

Ether is the name of the currency used within Ethereum

Info {#ether-info}

SPOILER: There are about 77 million ethers in existence and every new block (an average of 15 seconds) creates 5 new ether.

Exchanges {#exchanges}

Where you can trade ethers - Remember: if you don't control the private you don't really control the ethers

Faucets {#faucets}

Free Ether? don't have big expectation :)

Mainnet

Testnet

Wallets {#wallets}

To store your ethers

  • Mist - Mist - Official wallet with integrated full node.
  • Jaxx - By KryptoKit, Wallets that unify the Bitcoin and Ethereum experience accross Devices.
  • Myetherwallet - Open Source JavaScript Client-Side Ether Wallet.
  • Icebox - Lightwallet-powered cold storage solution..

Mining {#mining}

let's make the network work! and earn some ethers!

How to {#mining-hoe-to}

Mining pools {#mining-pools}

Fell alone? join a pool

Smart Contract languages {#smart-contracts-languages}

Solidity

Solidity, the JavaScript-like language

Serpent

Serpent, the Python-like language

LLL

LLL, the Lisp-like languagee

DAPP {#dapp}

Tutorials {#tutorials}

IDE {#ide}

Others awesome things & concepts {#others}

Casper {#casper}

  • Casper - Casper - Proof of Work (PoW) for Serenity.
  • Research - ethereum/research

Whisper {#whisper}

an upcoming P2P messaging protocol that will be integrated into the EtherBrowser.

  • Whisper Wiki Wiki article about Whisper ( December 2014)-
  • Whisper ? - What is Whisper and what is it used for?.

Swarm {#swarm}

  • Swarm - Swarm for Storage .

web3-j {#web3-j}

Ethereum compatible JavaScript API which implements the Generic JSON RPC spec.

Gas {#gas}

Gas is the fundamental network cost unit and is paid for exclusively in ether.

  • Gas Doc - Gas and transaction costs from the Ethereum Documentation.
  • What is Gas? - What is the “Gas” in Ethereum? -Post from CryptoCompare.
  • Cost calculator - Calculate the cost of conducting a transaction or executing a contract on Ethereum.

Projects using Ethereum {#projects}

Big ones

  • Augur - Prediction Market.
  • Slock.it - Rent, sell or share anything - without middlemen.
  • Digix - Transparent asset tracking of LBMA GOLD with blockchain technology 2.0.

Lists of projects

Companies {#companies}

Community {#community}

Social {#social}

Skype {#skype}

Main Skype Channels

  • Ethereum - Ethereum: the main channel, bridged to IRC #ethereum.
  • Ethereum-dev - Ethereum-dev: the developer's channel, bridged to IRC #ethereum-dev.

Speciality Skype Channels

Regional Skype Channels

  • London - London General: London-based Etherians.
  • Italia - Italia: Italian Etherians.
  • Romania - Romania: Romanian Etherians.
  • Russia - Russia - Russian Etherians (Russian language).

Gitter channels

IRC channels (Freenode)

  • Go-Ethereum -
    • #ethereum: for general discussion
    • #ethereum-dev: for development specific questions and discussions
    • ##ethereum: for offtopic and banter
    • #ethereum-mining: for mining only conversations
    • #ethereum-markets: for discussions about markets

Meetups {#meetups}

Events {#events}

Devcon

Stay up to date! {#up-to-date}

Newsletter {#newsletter}

Podcast {#podcast}

Contributing

Your contributions are always welcome! Please take a look at the contribution guidelines first.

I would keep some pull requests open if I'm not sure whether the content are awesome, you could vote for them by leaving a comment that contains +1.

To be added

  • Jobs
  • Courses

Download details:

Author: lampGit
Source code: https://github.com/lampGit/awesome-ethereum

#ethereum 

Rust Blockchain

Rust Blockchain

1645881000

Rust Web3: Rust implementation of Web3.js library with Ethereum

rust-web3

Ethereum JSON-RPC multi-transport client. Rust implementation of Web3.js library.

Documentation

Usage

First, add this to your Cargo.toml:

[dependencies]
web3 = { git = "https://github.com/tomusdrw/rust-web3" }

Next, add this to your crate:

extern crate web3;

Examples

extern crate web3;

use web3::futures::Future;

fn main() {
  let (_eloop, transport) = web3::transports::Http::new("http://localhost:8545").unwrap();
  let web3 = web3::Web3::new(transport);
  let accounts = web3.eth().accounts().wait().unwrap();

  println!("Accounts: {:?}", accounts);
}

If you want to deploy smart contracts you have written you can do something like this (make sure you have the solidity compiler installed):

solc -o build --bin --abi contracts/*.sol

The solidity compiler is generating the binary and abi code for the smart contracts in a directory called contracts and is being output to a directory called build.

For more see examples folder.

General

  •  More flexible API (accept Into<X>)
  •  Contract calls (ABI encoding; debris/ethabi)
  •  Batch Requests

Transports

  •  HTTP transport
  •  IPC transport
  •  WebSockets transport

Types

  •  Types for U256,H256,Address(H160)
  •  Index type (numeric, encoded to hex)
  •  Transaction type (Transaction from Parity)
  •  Transaction receipt type (TransactionReceipt from Parity)
  •  Block type (RichBlock from Parity)
  •  Work type (Work from Parity)
  •  Syncing type (SyncStats from Parity)

APIs

  •  Eth: eth_*
  •  Eth filters: eth_*
  •  Eth pubsub: eth_*
  •  net_*
  •  web3_*
  •  personal_*
  •  traces_*

Parity-specific APIs

  •  Parity read-only: parity_*
  •  Parity accounts: parity_* (partially implemented)
  •  Parity set: parity_*
  •  signer_*
  •  Own APIs (Extendable)
let web3 = Web3::new(transport);
web3.api::<CustomNamespace>().custom_method().wait().unwrap()

Installation on Windows

Currently, Windows does not support IPC, which is enabled in the library by default. To complile, you need to disable IPC feature:

web3 = { version = "0.1.0", default-features = false, features = ["http"] }

Download Details:
Author: gakonst
Source Code: https://github.com/gakonst/rust-web3
License: MIT License

#rust  #blockchain  #ethereum #web3 #json 

Andre Fisher

Andre Fisher

1658979660

Web3: Ethereum JSON-RPC Multi-transport Client with Rust

web3

Ethereum JSON-RPC multi-transport client. Rust implementation of Web3.js library.

Documentation: crates.io

Usage

First, add this to your Cargo.toml:

[dependencies]
web3 = "0.17.0"

Example

#[tokio::main]
async fn main() -> web3::Result<()> {
    let transport = web3::transports::Http::new("http://localhost:8545")?;
    let web3 = web3::Web3::new(transport);

    println!("Calling accounts.");
    let mut accounts = web3.eth().accounts().await?;
    println!("Accounts: {:?}", accounts);
    accounts.push("00a329c0648769a73afac7f9381e08fb43dbea72".parse().unwrap());

    println!("Calling balance.");
    for account in accounts {
        let balance = web3.eth().balance(account, None).await?;
        println!("Balance of {:?}: {}", account, balance);
    }

    Ok(())
}

If you want to deploy smart contracts you have written you can do something like this (make sure you have the solidity compiler installed):

solc -o build --bin --abi contracts/*.sol

The solidity compiler is generating the binary and abi code for the smart contracts in a directory called contracts and is being output to a directory called build.

For more see examples folder.

Futures migration

  •  Get rid of parking_lot (replace with async-aware locks if really needed).
  •  Consider getting rid of Unpin requirements. (#361)
  •  WebSockets: TLS support (#360)
  •  WebSockets: Reconnecting & Pings
  •  Consider using tokio instead of async-std for ws.rs transport (issue with test).
  •  Restore IPC Transport

General

  •  More flexible API (accept Into<X>)
  •  Contract calls (ABI encoding; debris/ethabi)
  •  Batch Requests

Transports

  •  HTTP transport
  •  IPC transport
  •  WebSockets transport

Types

  •  Types for U256,H256,Address(H160)
  •  Index type (numeric, encoded to hex)
  •  Transaction type (Transaction from Parity)
  •  Transaction receipt type (TransactionReceipt from Parity)
  •  Block type (RichBlock from Parity)
  •  Work type (Work from Parity)
  •  Syncing type (SyncStats from Parity)

APIs

  •  Eth: eth_*
  •  Eth filters: eth_*
  •  Eth pubsub: eth_*
  •  net_*
  •  web3_*
  •  personal_*
  •  traces_*

Parity-specific APIs

 Parity read-only: parity_*

 Parity accounts: parity_* (partially implemented)

 Parity set: parity_*

 signer_*

 Own APIs (Extendable)

let web3 = Web3::new(transport);
web3.api::<CustomNamespace>().custom_method().wait().unwrap()

Installation on Windows

Currently, Windows does not support IPC, which is enabled in the library by default. To compile, you need to disable the IPC feature:

web3 = { version = "0.17.0", default-features = false, features = ["http"] }

Avoiding OpenSSL dependency

On Linux, native-tls is implemented using OpenSSL. To avoid that dependency for HTTPS use the corresponding feature.

web3 = { version = "0.17.0", default-features = false, features = ["http-rustls-tls"] }

Cargo Features

The library supports following features:

  • http - Enables HTTP transport (requires tokio runtime, because of hyper).
  • http-tls - Enables TLS support via reqwest/default-tls for HTTP transport (implies http; default).
  • http-native-tls - Enables TLS support via reqwest/native-tls for HTTP transport (implies http).
  • http-rustls-tls - Enables TLS support via reqwest/rustls-tls for HTTP transport (implies http).
  • ws-tokio - Enables WS transport using tokio runtime.
  • ws-tls-tokio - Enables TLS support for WS transport (implies ws-tokio; default).
  • ws-async-std - Enables WS transport using async-std runtime.
  • ws-tls-async-std - Enables TLS support for WS transport (implies ws-async-std).
  • ipc-tokio - Enables IPC transport using tokio runtime (default).
  • signing - Enable account namespace and local-signing support (default).
  • eip-1193 - Enable EIP-1193 support.
  • wasm - Compile for WASM (make sure to disable default features).
  • arbitrary_precision - Enable arbitrary_precision in serde_json.

Author: simonjiao
Source code: https://github.com/simonjiao/findora-agentd
License: MIT license

#rust #web3 

Awesome Rust

Awesome Rust

1654894080

Serde JSON: JSON Support for Serde Framework

Serde JSON

Serde is a framework for serializing and deserializing Rust data structures efficiently and generically.

[dependencies]
serde_json = "1.0"

You may be looking for:

JSON is a ubiquitous open-standard format that uses human-readable text to transmit data objects consisting of key-value pairs.

{
    "name": "John Doe",
    "age": 43,
    "address": {
        "street": "10 Downing Street",
        "city": "London"
    },
    "phones": [
        "+44 1234567",
        "+44 2345678"
    ]
}

There are three common ways that you might find yourself needing to work with JSON data in Rust.

  • As text data. An unprocessed string of JSON data that you receive on an HTTP endpoint, read from a file, or prepare to send to a remote server.
  • As an untyped or loosely typed representation. Maybe you want to check that some JSON data is valid before passing it on, but without knowing the structure of what it contains. Or you want to do very basic manipulations like insert a key in a particular spot.
  • As a strongly typed Rust data structure. When you expect all or most of your data to conform to a particular structure and want to get real work done without JSON's loosey-goosey nature tripping you up.

Serde JSON provides efficient, flexible, safe ways of converting data between each of these representations.

Operating on untyped JSON values

Any valid JSON data can be manipulated in the following recursive enum representation. This data structure is serde_json::Value.

enum Value {
    Null,
    Bool(bool),
    Number(Number),
    String(String),
    Array(Vec<Value>),
    Object(Map<String, Value>),
}

A string of JSON data can be parsed into a serde_json::Value by the serde_json::from_str function. There is also from_slice for parsing from a byte slice &[u8] and from_reader for parsing from any io::Read like a File or a TCP stream.

use serde_json::{Result, Value};

fn untyped_example() -> Result<()> {
    // Some JSON input data as a &str. Maybe this comes from the user.
    let data = r#"
        {
            "name": "John Doe",
            "age": 43,
            "phones": [
                "+44 1234567",
                "+44 2345678"
            ]
        }"#;

    // Parse the string of data into serde_json::Value.
    let v: Value = serde_json::from_str(data)?;

    // Access parts of the data by indexing with square brackets.
    println!("Please call {} at the number {}", v["name"], v["phones"][0]);

    Ok(())
}

The result of square bracket indexing like v["name"] is a borrow of the data at that index, so the type is &Value. A JSON map can be indexed with string keys, while a JSON array can be indexed with integer keys. If the type of the data is not right for the type with which it is being indexed, or if a map does not contain the key being indexed, or if the index into a vector is out of bounds, the returned element is Value::Null.

When a Value is printed, it is printed as a JSON string. So in the code above, the output looks like Please call "John Doe" at the number "+44 1234567". The quotation marks appear because v["name"] is a &Value containing a JSON string and its JSON representation is "John Doe". Printing as a plain string without quotation marks involves converting from a JSON string to a Rust string with as_str() or avoiding the use of Value as described in the following section.

The Value representation is sufficient for very basic tasks but can be tedious to work with for anything more significant. Error handling is verbose to implement correctly, for example imagine trying to detect the presence of unrecognized fields in the input data. The compiler is powerless to help you when you make a mistake, for example imagine typoing v["name"] as v["nmae"] in one of the dozens of places it is used in your code.

Parsing JSON as strongly typed data structures

Serde provides a powerful way of mapping JSON data into Rust data structures largely automatically.

use serde::{Deserialize, Serialize};
use serde_json::Result;

#[derive(Serialize, Deserialize)]
struct Person {
    name: String,
    age: u8,
    phones: Vec<String>,
}

fn typed_example() -> Result<()> {
    // Some JSON input data as a &str. Maybe this comes from the user.
    let data = r#"
        {
            "name": "John Doe",
            "age": 43,
            "phones": [
                "+44 1234567",
                "+44 2345678"
            ]
        }"#;

    // Parse the string of data into a Person object. This is exactly the
    // same function as the one that produced serde_json::Value above, but
    // now we are asking it for a Person as output.
    let p: Person = serde_json::from_str(data)?;

    // Do things just like with any other Rust data structure.
    println!("Please call {} at the number {}", p.name, p.phones[0]);

    Ok(())
}

This is the same serde_json::from_str function as before, but this time we assign the return value to a variable of type Person so Serde will automatically interpret the input data as a Person and produce informative error messages if the layout does not conform to what a Person is expected to look like.

Any type that implements Serde's Deserialize trait can be deserialized this way. This includes built-in Rust standard library types like Vec<T> and HashMap<K, V>, as well as any structs or enums annotated with #[derive(Deserialize)].

Once we have p of type Person, our IDE and the Rust compiler can help us use it correctly like they do for any other Rust code. The IDE can autocomplete field names to prevent typos, which was impossible in the serde_json::Value representation. And the Rust compiler can check that when we write p.phones[0], then p.phones is guaranteed to be a Vec<String> so indexing into it makes sense and produces a String.

The necessary setup for using Serde's derive macros is explained on the Using derive page of the Serde site.

Constructing JSON values

Serde JSON provides a json! macro to build serde_json::Value objects with very natural JSON syntax.

use serde_json::json;

fn main() {
    // The type of `john` is `serde_json::Value`
    let john = json!({
        "name": "John Doe",
        "age": 43,
        "phones": [
            "+44 1234567",
            "+44 2345678"
        ]
    });

    println!("first phone number: {}", john["phones"][0]);

    // Convert to a string of JSON and print it out
    println!("{}", john.to_string());
}

The Value::to_string() function converts a serde_json::Value into a String of JSON text.

One neat thing about the json! macro is that variables and expressions can be interpolated directly into the JSON value as you are building it. Serde will check at compile time that the value you are interpolating is able to be represented as JSON.

let full_name = "John Doe";
let age_last_year = 42;

// The type of `john` is `serde_json::Value`
let john = json!({
    "name": full_name,
    "age": age_last_year + 1,
    "phones": [
        format!("+44 {}", random_phone())
    ]
});

This is amazingly convenient, but we have the problem we had before with Value: the IDE and Rust compiler cannot help us if we get it wrong. Serde JSON provides a better way of serializing strongly-typed data structures into JSON text.

Creating JSON by serializing data structures

A data structure can be converted to a JSON string by serde_json::to_string. There is also serde_json::to_vec which serializes to a Vec<u8> and serde_json::to_writer which serializes to any io::Write such as a File or a TCP stream.

use serde::{Deserialize, Serialize};
use serde_json::Result;

#[derive(Serialize, Deserialize)]
struct Address {
    street: String,
    city: String,
}

fn print_an_address() -> Result<()> {
    // Some data structure.
    let address = Address {
        street: "10 Downing Street".to_owned(),
        city: "London".to_owned(),
    };

    // Serialize it to a JSON string.
    let j = serde_json::to_string(&address)?;

    // Print, write to a file, or send to an HTTP server.
    println!("{}", j);

    Ok(())
}

Any type that implements Serde's Serialize trait can be serialized this way. This includes built-in Rust standard library types like Vec<T> and HashMap<K, V>, as well as any structs or enums annotated with #[derive(Serialize)].

Performance

It is fast. You should expect in the ballpark of 500 to 1000 megabytes per second deserialization and 600 to 900 megabytes per second serialization, depending on the characteristics of your data. This is competitive with the fastest C and C++ JSON libraries or even 30% faster for many use cases. Benchmarks live in the serde-rs/json-benchmark repo.

Getting help

Serde is one of the most widely used Rust libraries, so any place that Rustaceans congregate will be able to help you out. For chat, consider trying the #rust-questions or #rust-beginners channels of the unofficial community Discord (invite: https://discord.gg/rust-lang-community), the #rust-usage or #beginners channels of the official Rust Project Discord (invite: https://discord.gg/rust-lang), or the #general stream in Zulip. For asynchronous, consider the [rust] tag on StackOverflow, the /r/rust subreddit which has a pinned weekly easy questions post, or the Rust Discourse forum. It's acceptable to file a support issue in this repo, but they tend not to get as many eyes as any of the above and may get closed without a response after some time.

No-std support

As long as there is a memory allocator, it is possible to use serde_json without the rest of the Rust standard library. This is supported on Rust 1.36+. Disable the default "std" feature and enable the "alloc" feature:

[dependencies]
serde_json = { version = "1.0", default-features = false, features = ["alloc"] }

For JSON support in Serde without a memory allocator, please see the serde-json-core crate.

Link: https://crates.io/crates/serde_json

#rust  #rustlang  #encode   #json 

Adaline Kulas

Adaline Kulas

1594162500

Multi-cloud Spending: 8 Tips To Lower Cost

A multi-cloud approach is nothing but leveraging two or more cloud platforms for meeting the various business requirements of an enterprise. The multi-cloud IT environment incorporates different clouds from multiple vendors and negates the dependence on a single public cloud service provider. Thus enterprises can choose specific services from multiple public clouds and reap the benefits of each.

Given its affordability and agility, most enterprises opt for a multi-cloud approach in cloud computing now. A 2018 survey on the public cloud services market points out that 81% of the respondents use services from two or more providers. Subsequently, the cloud computing services market has reported incredible growth in recent times. The worldwide public cloud services market is all set to reach $500 billion in the next four years, according to IDC.

By choosing multi-cloud solutions strategically, enterprises can optimize the benefits of cloud computing and aim for some key competitive advantages. They can avoid the lengthy and cumbersome processes involved in buying, installing and testing high-priced systems. The IaaS and PaaS solutions have become a windfall for the enterprise’s budget as it does not incur huge up-front capital expenditure.

However, cost optimization is still a challenge while facilitating a multi-cloud environment and a large number of enterprises end up overpaying with or without realizing it. The below-mentioned tips would help you ensure the money is spent wisely on cloud computing services.

  • Deactivate underused or unattached resources

Most organizations tend to get wrong with simple things which turn out to be the root cause for needless spending and resource wastage. The first step to cost optimization in your cloud strategy is to identify underutilized resources that you have been paying for.

Enterprises often continue to pay for resources that have been purchased earlier but are no longer useful. Identifying such unused and unattached resources and deactivating it on a regular basis brings you one step closer to cost optimization. If needed, you can deploy automated cloud management tools that are largely helpful in providing the analytics needed to optimize the cloud spending and cut costs on an ongoing basis.

  • Figure out idle instances

Another key cost optimization strategy is to identify the idle computing instances and consolidate them into fewer instances. An idle computing instance may require a CPU utilization level of 1-5%, but you may be billed by the service provider for 100% for the same instance.

Every enterprise will have such non-production instances that constitute unnecessary storage space and lead to overpaying. Re-evaluating your resource allocations regularly and removing unnecessary storage may help you save money significantly. Resource allocation is not only a matter of CPU and memory but also it is linked to the storage, network, and various other factors.

  • Deploy monitoring mechanisms

The key to efficient cost reduction in cloud computing technology lies in proactive monitoring. A comprehensive view of the cloud usage helps enterprises to monitor and minimize unnecessary spending. You can make use of various mechanisms for monitoring computing demand.

For instance, you can use a heatmap to understand the highs and lows in computing visually. This heat map indicates the start and stop times which in turn lead to reduced costs. You can also deploy automated tools that help organizations to schedule instances to start and stop. By following a heatmap, you can understand whether it is safe to shut down servers on holidays or weekends.

#cloud computing services #all #hybrid cloud #cloud #multi-cloud strategy #cloud spend #multi-cloud spending #multi cloud adoption #why multi cloud #multi cloud trends #multi cloud companies #multi cloud research #multi cloud market