Numerical Types in Rust with VSCode

Taswar Bhatti September 28, 2021 No Comments

I wanted to talk about basic types in Rust. Lets begin with Numerical Types in Rust, since Rust is a statically typed language, which means that it must know the types of all variables at compile time. I will talk about number types that are built into the language.

Numerical Types

Numerical values are divided into Integer Types and Floating-point type. A simple numerical type can be signed integer types or unsigned integer types.

Signed integer types start with i instead of u

Integer Data types are listed below:

i8 : The 8-bit signed integer type.
i16 : The 16-bit signed integer type.
i32 : The 32-bit signed integer type.
i64 : The 64-bit signed integer type.
u8 : The 8-bit unsigned integer type.
u16 : The 16-bit unsigned integer type.
u32 : The 32-bit unsigned integer type.
u64 : The 64-bit unsigned integer type.
isize : The pointer-sized signed integer type.
usize : The pointer-sized unsigned integer type.

Type	MAX	MIN
i8	127	-128
i16	32767	-32768
i32	2147483647	-2147483648
i64	9223372036854775807	-9223372036854775808
i128	170141183460469231731687303715884105727	-170141183460469231731687303715884105728
u8	0	255
u16	0	65535
u32	0	4294967295
u64	0	18446744073709551615
u128	0	340282366920938463463374607431768211455

let a = 100; // The default integer type in Rust is i32
let b: i8 = -128; //explicitly telling it will be an i8 type
let x = 2i8; // Equals to `let x: i8 = 2;` personally I don't like this way of, I prefer the previous statement rather

1

2

3

let a = 100; // The default integer type in Rust is i32

let b: i8 = -128; //explicitly telling it will be an i8 type

let x = 2i8; // Equals to `let x: i8 = 2;` personally I don't like this way of, I prefer the previous statement rather

Floating Point data types are simplier, there is only 2 types.

f32 : The 32-bit floating point type.
64 : The 64-bit floating point type.

let x = 1.5; // The default float type in Rust is f64
let y: f32 = 2.0; // setting default to f32

1 2	let x = 1.5; // The default float type in Rust is f64 let y: f32 = 2.0; // setting default to f32

Summary

This was a short intro to the numerical values and the limits of each value in Rust.

Rust, VSCode

rust, rustlang, vscode

Functions in Rust with VSCode

Taswar Bhatti September 21, 2021 No Comments

Continuting on from where we left off, in this post I will refactor my code to use a function such that I can reuse my code later on. I will showcase how to write Functions in Rust with VSCode.

Intro

If we look at our previous post we have a very simple main function and it is just getting user input and then it outputs it with the println method. Its not one of the most elegant code but we we taking baby steps here. As a preview of our code code, it looks like below.

use std::io::stdin;
fn main() {
    let mut name = String::new();
    println!("Please enter your name &gt;");
    stdin().read_line(&amp;mut name).expect("Failed input");
    println!("Hello {}", name);
}

1

2

3

4

5

6

7

use std::io::stdin;

fn main() {

let mut name = String::new();

println!("Please enter your name >");

stdin().read_line(&mut name).expect("Failed input");

println!("Hello {}", name);

}

Now we would like to extract the read_line into its own function, the way we will do it is like below, I will explain in details after the code sample.

use std::io::stdin;

fn get_name() -&gt; String {
    let mut name = String::new();    
    stdin()
    .read_line(&amp;mut name)
    .expect("Failed input");
    name.trim().to_string()
}

fn main() {    
    println!("Please enter your name: ");
    let name = get_name();
    println!("Hello {}", name);
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

use std::io::stdin;

fn get_name() -> String {

let mut name = String::new();

stdin()

.read_line(&mut name)

.expect("Failed input");

name.trim().to_string()

}

fn main() {

println!("Please enter your name: ");

let name = get_name();

println!("Hello {}", name);

}

What I have done is create a function with the fn keyword and named it get_name, afterwards you see a -> character which tells the function that it will be returning a String.

You do not need a return statement in Rust the last value in the function acts as a return value

I have also called the trim function, the only issue is it returns a str rather than a String so I have to call to_string() in order to convert it back to String.

pub fn trim(&self) -> &str
Returns a string slice with leading and trailing whitespace removed.

If we run the program we will see this kind of output.

$ cargo run -q
Please enter your name: 
Taswar
Hello Taswar

1

2

3

4

$ cargo run -q

Please enter your name:

Taswar

Hello Taswar

Now I dont know if you are like me, but I don’t like the output of this code, the input readline is right after the print statement. I would like to have the input right at the first line where it states “Pleaes enter your name:”. Let’s try to modify our code so that we can get the input in the same line.

use std::io::stdin;
use std::io::{self, Write};

fn get_name() -&gt; String {
    let mut name = String::new();    
    stdin()
    .read_line(&amp;mut name)
    .expect("Failed input");
    name.trim().to_string()
}

fn main() {    
    print!("Please enter your name: ");
    io::stdout().flush().unwrap();

    let name = get_name();
    println!("Hello {}", name);
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

use std::io::stdin;

use std::io::{self, Write};

fn get_name() -> String {

let mut name = String::new();

stdin()

.read_line(&mut name)

.expect("Failed input");

name.trim().to_string()

}

fn main() {

print!("Please enter your name: ");

io::stdout().flush().unwrap();

let name = get_name();

println!("Hello {}", name);

}

What you see is I have first imported std::io::{self, Write};. So what this does is it imports std::io; and also use std::io::Write;. Therefore we can use the call for io::stdout().flush().unwrap();, since we imported std::io also.

Now if we run the program, we will get the code formatted in the way we want to.

$ cargo run -q
Please enter your name: Taswar
Hello Taswar

1

2

3

$ cargo run -q

Please enter your name: Taswar

Hello Taswar

Summary

So we have seen how to refactor our code into a function and in our next section lets build on this concept but change it to a game as simple as Rock, Paper, Scissors.

Rust, VSCode

rust, rustlang, vscode

Capturing User Input in Rust with VSCode

Taswar Bhatti September 15, 2021 No Comments

In this post we are going to take our baby steps in learning Rust and the simple example of a hello world would not just cut it. We will now introduce how to Capturing User Input in Rust.

Intro

To get started we will use our trusty cargo package manager again to create a new project for us. If you have not used cargo yet, please look back at my previous post on how to setup cargo.

$cargo new hellouser

1	$cargo new hellouser

This will create a file system looking like below.

.
├── Cargo.lock
├── Cargo.toml
├── src
│   └── main.rs
└── target
    ├── CACHEDIR.TAG
    ├── debug
    └── rls

1

2

3

4

5

6

7

8

9

.

├── Cargo.lock

├── Cargo.toml

├── src

│ └── main.rs

└── target

├── CACHEDIR.TAG

├── debug

└── rls

We will open the main.rs file and modify it. We will add a variable to hold the value of the username. One thing to remember is Rust variables default to being immutable. Once an immutable variable is assigned, you cannot change the value stored in the variable. There is also a way to explicity to make a variable as mutable and you will need to use the mut keyword for that. So lets try to add a varible named “name” like the code below.

fn main() {
    let mut name = String::new();
    println!("Please enter your name>");
}

1

2

3

4

fn main() {

let mut name = String::new();

println!("Please enter your name>");

}

As you can see above we have defined a variable using the let keyword and we have also defined it as mut so that is is mutable i.e change its value after creation.

You may have also noticed something as in String::new, this is how you defined a String which is a growable, heap-allocated data structure. There is also a type in Rust called str which is an immutable fixed-length UTF-8 bytes of dynamic length string somewhere in memory. If you come from a C++ or C programming lang you can think of String like std::string and str as char*, if that helps.

Getting input from terminal

Now onto how to capture input, inorder to get input one has to use the stdin library of Rust. Rust provides terminal input functions in std::io::stdin. There is a read_line function in stdin, and we need to use the use keyword to import the functionality into our program. Below is how our Rust program will look like.

use std::io::stdin;
fn main() {
    let mut name = String::new();
    println!("Please enter your name >");
    stdin().read_line(&mut name).expect("Failed input");
    println!("Hello {}", name);
}

1

2

3

4

5

6

7

use std::io::stdin;

fn main() {

let mut name = String::new();

println!("Please enter your name >");

stdin().read_line(&mut name).expect("Failed input");

println!("Hello {}", name);

}

So what we have done here is we are using the stdin() whcih returns an object granting access to the Standard Input. Afterwards we have called the read_line method passing in a Borrow variable with the & sign which allows changes to be made to the variable by the function. In this case we have passed in name as a Borrow variable, which creates a reference to the variable. (I will cover Borrow in later topics).

Afterwards we also have an expect function which if the program crashes Rust returns a Result object, basically you are checking that the function worked by calling expect. Lastly we are using placeholders to print the value of name. Now lets try to run the program.

$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.00s
     Running `target/debug/hellouser`
Please enter your name >
Taswar
Hello Taswar
&nbsp;

1

2

3

4

5

6

7

$ cargo run

Finished dev [unoptimized + debuginfo] target(s) in 0.00s

Running `target/debug/hellouser`

Please enter your name >

Taswar

Hello Taswar

As you can see above I have enter my name “Taswar” and it outputs “Hello Taswar” with a newline aftewards. We can use the trim function in String to remove it but for that I will cover in the next section of how to write a function around the input.

Summary

In this post we learned how to read user input in a terminal in Rust, in the next section we will refactor and cover how to write functions in Rust.

Rust, VSCode

rust, rust lang, vscode

Writing and Running Intergration Tests with Rust in VSCode

Taswar Bhatti September 8, 2021 No Comments

In this post I will go over how to write Unit test for your Rust application. We will continue with where we left off with the hello world program and see what Rust has to offer us in unit testing. Note: I will be Writing and Running Intergration Tests with Rust in VSCode.

Creating Rust test directory

#install the pre req
$ mkdir tests
$ touch tests/hello_tests.rs

1

2

3

#install the pre req

$ mkdir tests

$ touch tests/hello_tests.rs

Our directory would look something like below.

.
├── Cargo.lock
├── Cargo.toml
├── src
│   └── main.rs
├── target
│   ├── CACHEDIR.TAG
│   ├── debug
│   └── rls
└── tests
    └── hello_tests.rs

5 directories, 5 files

1

2

3

4

5

6

7

8

9

10

11

12

13

.

├── Cargo.lock

├── Cargo.toml

├── src

│ └── main.rs

├── target

│ ├── CACHEDIR.TAG

│ ├── debug

│ └── rls

└── tests

└── hello_tests.rs

5 directories, 5 files

In our hellow_tests.rs file we will add the code like below, if you are coming from a C# or Java background, Rust also uses Attribute for test so it will look quite familiar, using # tag followed by [test] brackets. We are using assert! just to pass this test.

#[test]
fn test_hello_output() {
  assert!(true);
}

1

2

3

4

#[test]

fn test_hello_output() {

assert!(true);

}

To run the test we can run the cargo test command like below.

$ cargo test
   Compiling hello v0.1.0 (/home/taswar/hello)
    Finished test [unoptimized + debuginfo] target(s) in 1.51s
     Running unittests (target/debug/deps/hello-b89e93aae08f04d4)

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

     Running tests/hello_tests.rs (target/debug/deps/hello_tests-8e52de7efe492fbd)

running 1 test
test test_hello_output ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

$ cargo test

Compiling hello v0.1.0 (/home/taswar/hello)

Finished test [unoptimized + debuginfo] target(s) in 1.51s

Running unittests (target/debug/deps/hello-b89e93aae08f04d4)

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Running tests/hello_tests.rs (target/debug/deps/hello_tests-8e52de7efe492fbd)

running 1 test

test test_hello_output ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

If you remember we had our program output a simple println statement with Hello, world!, so our test needs to check the output of our program. In order to do so we will introduce a new cargo package into your system.

Lets modify our project dependency and use crate assert_cmd to find the program in our crate directory.

Adding development dependency to Cargo.toml

Open the file Cargo.toml and add the dev dependency like below.

[package]
name = "hello"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

[dev-dependencies]
assert_cmd = "1"

1

2

3

4

5

6

7

8

9

10

11

[package]

name = "hello"

version = "0.1.0"

edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

[dev-dependencies]

assert_cmd = "1"

Now we will need to modify our hellow_tests.rs file we will add the usage of the assert_cmd package.

use assert_cmd::Command;

#[test]
fn test_hello_output() {
    let mut program = Command::cargo_bin("hello").unwrap();
    program.assert().success().stdout("Hello, world!");
}

1

2

3

4

5

6

7

use assert_cmd::Command;

#[test]

fn test_hello_output() {

let mut program = Command::cargo_bin("hello").unwrap();

program.assert().success().stdout("Hello, world!");

}

Above you will see that I am using assert_cmd and have changed some of the code to use the Command library. In the above code you will also see I am using a strange variable naming “let mut”. You may wonder what that is?

let mut what is that?

So variables in Rust are immutable by default, and require the mut keyword to be made mutable here. I am also using cargo_bin so that it can automatically find the output of the hello world program.

Unwrap what is that?

You also see I am calling a function called unwrap, so unwrap() is used here to handle the errors quickly in our test. It can be used on any function that returns Result or Option (Option is also an enum). If the function returns an Ok(value), you will get the value. If the function returns an Err(error), the program/test will panic. In our case if it does not find the hello program it will be in panic mode.

Next I have used assert with success to find out the command was successful and trying to match the Hello, world! output. If we run this test we will see that it will fail.

$ cargo test
    Finished test [unoptimized + debuginfo] target(s) in 0.03s
     Running unittests (target/debug/deps/hello-06d7198787a084e0)

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

     Running tests/hello_tests.rs (target/debug/deps/hello_tests-5abafa31ab2a94f9)

running 1 test
test test_hello_output ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

taswar@IST11-800491469:~/hello$ cargo test
    Finished test [unoptimized + debuginfo] target(s) in 0.02s
     Running unittests (target/debug/deps/hello-06d7198787a084e0)

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

     Running tests/hello_tests.rs (target/debug/deps/hello_tests-5abafa31ab2a94f9)

running 1 test
test test_hello_output ... FAILED

failures:

---- test_hello_output stdout ----
thread 'test_hello_output' panicked at 'Unexpected stdout, failed diff original var
├── original: Hello, world!
├── diff: 
└── var as str: Hello, world!

command=`"/home/taswar/hello/target/debug/hello"`
code=0
stdout=```"Hello, world!\n"```
stderr=```""```
', /home/taswar/.cargo/registry/src/github.com-1ecc6299db9ec823/assert_cmd-1.0.8/src/assert.rs:124:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    test_hello_output

test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass '--test hello_tests'

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

$ cargo test

Finished test [unoptimized + debuginfo] target(s) in 0.03s

Running unittests (target/debug/deps/hello-06d7198787a084e0)

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Running tests/hello_tests.rs (target/debug/deps/hello_tests-5abafa31ab2a94f9)

running 1 test

test test_hello_output ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

taswar@IST11-800491469:~/hello$ cargo test

Finished test [unoptimized + debuginfo] target(s) in 0.02s

Running unittests (target/debug/deps/hello-06d7198787a084e0)

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Running tests/hello_tests.rs (target/debug/deps/hello_tests-5abafa31ab2a94f9)

running 1 test

test test_hello_output ... FAILED

failures:

---- test_hello_output stdout ----

thread 'test_hello_output' panicked at 'Unexpected stdout, failed diff original var

├── original: Hello, world!

├── diff:

└── var as str: Hello, world!

command=`"/home/taswar/hello/target/debug/hello"`

code=0

stdout=```"Hello, world!\n"```

stderr=```""```

', /home/taswar/.cargo/registry/src/github.com-1ecc6299db9ec823/assert_cmd-1.0.8/src/assert.rs:124:9

note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

failures:

test_hello_output

test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass '--test hello_tests'

One may wonder what is wrong with it, so basically what we are missing is the newline character in our test \n in our stdout, so lets modify our test code and add the newline character.

use assert_cmd::Command;

#[test]
fn test_hello_output() {
    let mut program = Command::cargo_bin("hello").unwrap();
    program.assert().success().stdout("Hello, world!\n");
}

1

2

3

4

5

6

7

use assert_cmd::Command;

#[test]

fn test_hello_output() {

let mut program = Command::cargo_bin("hello").unwrap();

program.assert().success().stdout("Hello, world!\n");

}

Now the output of our test should be passing.

cargo test
   Compiling hello v0.1.0 (/home/taswar/hello)
    Finished test [unoptimized + debuginfo] target(s) in 1.39s
     Running unittests (target/debug/deps/hello-06d7198787a084e0)

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

     Running tests/hello_tests.rs (target/debug/deps/hello_tests-5abafa31ab2a94f9)

running 1 test
test test_hello_output ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

cargo test

Compiling hello v0.1.0 (/home/taswar/hello)

Finished test [unoptimized + debuginfo] target(s) in 1.39s

Running unittests (target/debug/deps/hello-06d7198787a084e0)

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Running tests/hello_tests.rs (target/debug/deps/hello_tests-5abafa31ab2a94f9)

running 1 test

test test_hello_output ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Summary

I understand the fact that this is a very brittle test checking the output of our program to match a certain string. The idea of this is for you to learn how to write simple unit test in Rust and how the ecosystem works. I hope this helps in your journey, we will continue on our learning Rust journey to write simple unix/linux command line tools and built upon that.

Rust, VSCode

rust, vscode

Learning Rust with VSCode

Taswar Bhatti September 1, 2021 No Comments

I recently started to look into Rust and found it quite interesting and fun to work with, reminded me of working a bit like go and C lang. Thus I though it would be good to go through a blog series on of learning Rust with VSCode.

I will be using WSL Ubuntu 20.04.3 LTS for my development. If you are not using WSL yet, it allows you to have a linux terminal right inside of your windows desktop. Windows Subsystem for Linux 2) allows users to run a Linux VM inside windows and gives a near native Linux experience.

Installing Rust

Lets install Rust in your Ubuntu environment.

#install the pre req
$ sudo apt install build-essential 

#Install Rust select 1 and Proceed with installation (default)
$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

1

2

3

4

5

#install the pre req

$ sudo apt install build-essential

#Install Rust select 1 and Proceed with installation (default)

$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

The output of the command would look like below.

info: downloading installer

Welcome to Rust!

This will download and install the official compiler for the Rust
programming language, and its package manager, Cargo.

Rustup metadata and toolchains will be installed into the Rustup
home directory, located at:

  /home/taswar/.rustup

This can be modified with the RUSTUP_HOME environment variable.

The Cargo home directory located at:

  /home/taswar/.cargo

This can be modified with the CARGO_HOME environment variable.

The cargo, rustc, rustup and other commands will be added to
Cargo's bin directory, located at:

  /home/taswar/.cargo/bin

This path will then be added to your PATH environment variable by
modifying the profile files located at:

  /home/taswar/.profile
  /home/taswar/.bashrc

You can uninstall at any time with rustup self uninstall and
these changes will be reverted.

Current installation options:


   default host triple: x86_64-unknown-linux-gnu
     default toolchain: stable (default)
               profile: default
  modify PATH variable: yes

1) Proceed with installation (default)
2) Customize installation
3) Cancel installation
>1

info: profile set to 'default'
info: default host triple is x86_64-unknown-linux-gnu
info: syncing channel updates for 'stable-x86_64-unknown-linux-gnu'
info: latest update on 2022-01-20, rust version 1.58.1 (db9d1b20b 2022-01-20)
info: downloading component 'cargo'
info: downloading component 'clippy'
info: downloading component 'rust-docs'
 18.9 MiB /  18.9 MiB (100 %)  10.2 MiB/s in  1s ETA:  0s
info: downloading component 'rust-std'
 25.0 MiB /  25.0 MiB (100 %)  10.4 MiB/s in  2s ETA:  0s
info: downloading component 'rustc'
 53.2 MiB /  53.2 MiB (100 %)  10.2 MiB/s in  6s ETA:  0s
info: downloading component 'rustfmt'
info: installing component 'cargo'
info: installing component 'clippy'
info: installing component 'rust-docs'
 18.9 MiB /  18.9 MiB (100 %)   6.1 MiB/s in  3s ETA:  0s
info: installing component 'rust-std'
 25.0 MiB /  25.0 MiB (100 %)   8.8 MiB/s in  2s ETA:  0s
info: installing component 'rustc'
 53.2 MiB /  53.2 MiB (100 %)   9.2 MiB/s in  5s ETA:  0s
info: installing component 'rustfmt'
info: default toolchain set to 'stable-x86_64-unknown-linux-gnu'

  stable-x86_64-unknown-linux-gnu installed - rustc 1.58.1 (db9d1b20b 2022-01-20)


Rust is installed now. Great!

To get started you may need to restart your current shell.
This would reload your PATH environment variable to include
Cargo's bin directory ($HOME/.cargo/bin).

To configure your current shell, run:
source $HOME/.cargo/env

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

info: downloading installer

Welcome to Rust!

This will download and install the official compiler for the Rust

programming language, and its package manager, Cargo.

Rustup metadata and toolchains will be installed into the Rustup

home directory, located at:

/home/taswar/.rustup

This can be modified with the RUSTUP_HOME environment variable.

The Cargo home directory located at:

/home/taswar/.cargo

This can be modified with the CARGO_HOME environment variable.

The cargo, rustc, rustup and other commands will be added to

Cargo's bin directory, located at:

/home/taswar/.cargo/bin

This path will then be added to your PATH environment variable by

modifying the profile files located at:

/home/taswar/.profile

/home/taswar/.bashrc

You can uninstall at any time with rustup self uninstall and

these changes will be reverted.

Current installation options:

default host triple: x86_64-unknown-linux-gnu

default toolchain: stable (default)

profile: default

modify PATH variable: yes

1) Proceed with installation (default)

2) Customize installation

3) Cancel installation

>1

info: profile set to 'default'

info: default host triple is x86_64-unknown-linux-gnu

info: syncing channel updates for 'stable-x86_64-unknown-linux-gnu'

info: latest update on 2022-01-20, rust version 1.58.1 (db9d1b20b 2022-01-20)

info: downloading component 'cargo'

info: downloading component 'clippy'

info: downloading component 'rust-docs'

18.9 MiB / 18.9 MiB (100 %) 10.2 MiB/s in 1s ETA: 0s

info: downloading component 'rust-std'

25.0 MiB / 25.0 MiB (100 %) 10.4 MiB/s in 2s ETA: 0s

info: downloading component 'rustc'

53.2 MiB / 53.2 MiB (100 %) 10.2 MiB/s in 6s ETA: 0s

info: downloading component 'rustfmt'

info: installing component 'cargo'

info: installing component 'clippy'

info: installing component 'rust-docs'

18.9 MiB / 18.9 MiB (100 %) 6.1 MiB/s in 3s ETA: 0s

info: installing component 'rust-std'

25.0 MiB / 25.0 MiB (100 %) 8.8 MiB/s in 2s ETA: 0s

info: installing component 'rustc'

53.2 MiB / 53.2 MiB (100 %) 9.2 MiB/s in 5s ETA: 0s

info: installing component 'rustfmt'

info: default toolchain set to 'stable-x86_64-unknown-linux-gnu'

stable-x86_64-unknown-linux-gnu installed - rustc 1.58.1 (db9d1b20b 2022-01-20)

Rust is installed now. Great!

To get started you may need to restart your current shell.

This would reload your PATH environment variable to include

Cargo's bin directory ($HOME/.cargo/bin).

To configure your current shell, run:

source $HOME/.cargo/env

To verify your install try this command

$ source $HOME/.cargo/env
$ rustc --version
rustc 1.58.1 (db9d1b20b 2022-01-20)

1

2

3

$ source $HOME/.cargo/env

$ rustc --version

rustc 1.58.1 (db9d1b20b 2022-01-20)

Before we jump into VSCode, lets just try to create a simple hello world first in the most basic way without cargo (rust build manager, like npm).

Simple Hello World

Open a file and call it hello.rs and paste the code into it. You can use nano or vi or vim.

fn main() {
  println!("Hello, world!");
}

1

2

3

fn main() {

println!("Hello, world!");

}

We can then compile with rustc and it will create an executable that your computer can execute/

$ rustc hello.rs
$ ./hello
Hello, world!

1

2

3

$ rustc hello.rs

$ ./hello

Hello, world!

Creating and Running a Project with Cargo

Lets create a new project with cargo. You may wonder what is cargo. Cargo is the Rust package manager. Cargo downloads your Rust package’s dependencies, compiles your packages, makes distributable packages, and uploads them to crates.io, the Rust community’s package registry. We will execute on your shell prompt like below and look inside the directory.

$ cargo new hello
     Created binary (application) `hello` package
#it creates a directory called hello
#lets take a look inside the dir
$ cd hello
$ tree
.
├── Cargo.toml
└── src
    └── main.rs

1 directory, 2 files

1

2

3

4

5

6

7

8

9

10

11

12

$ cargo new hello

Created binary (application) `hello` package

#it creates a directory called hello

#lets take a look inside the dir

$ cd hello

$ tree

.

├── Cargo.toml

└── src

└── main.rs

1 directory, 2 files

What is this Cargo.toml

Cargo.toml is a configuration file for the project. The extension .toml stands for Tom’s Obvious, Minimal Language. Lets take a look at the file

$ cat Cargo.toml
[package]
name = "hello"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

1

2

3

4

5

6

7

8

9

$ cat Cargo.toml

[package]

name = "hello"

version = "0.1.0"

edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

We also have the main.rs file, let’s take a look inside that file also, we will see that it looks similar to our hello world from before. Cargo has created a hello world sample for us.

$ cat src/main.rs
fn main() {
    println!("Hello, world!");
}

1

2

3

4

$ cat src/main.rs

fn main() {

println!("Hello, world!");

}

This time rather than using rustc to compile the program, we will use cargo run to compile the source code and run it in one command:

$ cargo run
   Compiling hello v0.1.0 (/home/taswar/hello)
    Finished dev [unoptimized + debuginfo] target(s) in 0.64s
     Running `target/debug/hello`
Hello, world!

1

2

3

4

5

$ cargo run

Compiling hello v0.1.0 (/home/taswar/hello)

Finished dev [unoptimized + debuginfo] target(s) in 0.64s

Running `target/debug/hello`

Hello, world!

The first three lines are information about what Cargo is doing. We can also use cargo run -q to make the output to be quiet.

What about VSCode?

So we can just type code . in your terminal it will launch vscode for us and we can then go into the extension section and install rust and rust-analyzer.

Install Rust Extension

rust-extension-vscode

Run Rust in VSCode

If you install rust analyzer then you will see the Run and Debug command ontop of your code where you can click on the run command to run Rust like below.

Run_Rust_In_VSCode

Here is the output that will show on your terminal.

Output_Rust_Terminal

Summary

So here is a quick summary of how to get Rust to run with vscode, in the next sections I will go through more learning of Rust and how to have fun with it.

Rust, VSCode

rust, rust lang, vscode

Using AWS CDK to create IAM roles with C#

Taswar Bhatti April 20, 2021 No Comments

In this section we will talk about Identity and Access Management – IAM in short. I will show you an example of using AWS CDK to create IAM roles with C# and extending our current solution so that an IAM Role is ready with the correct permission to use. We will mainly focus on IAM Role and Policy. But first….

What is IAM?

AWS Identity and Access Management (IAM) enables you to manage access to AWS services and resources securely. Using IAM, you can create and manage AWS users and groups, and use permissions to allow and deny their access to AWS resources. IAM can help securely control individual and group access to your AWS resources. You can create and manage user identities, or IAM users, roles, policies and grant permissions for them to access the resources you wish to give permission to.

Additional things IAM Allows

Manage IAM users and their access – You can create users in IAM, assign them individual security credentials (in other words, access keys, passwords, and multi-factor authentication devices), or request temporary security credentials to provide users access to AWS services and resources. You can manage permissions in order to control which operations a user can perform.
Manage IAM roles and their permissions – You can create roles in IAM and manage permissions to control which operations can be performed by the entity, or AWS service, that assumes the role. You can also define which entity is allowed to assume the role. In addition, you can use service-linked roles to delegate permissions to AWS services that create and manage AWS resources on your behalf.
Manage federated users and their permissions – You can enable identity federation to allow existing identities (users, groups, and roles) in your enterprise to access the AWS Management Console, call AWS APIs, and access resources, without the need to create an IAM user for each identity. Use any identity management solution that supports SAML 2.0, or use one of our federation samples (AWS Console SSO or API federation).

(Additional information at: https://aws.amazon.com/iam/)

IAM Roles

In our case we wish to grant our applications that will run on an Amazon EC2 instances access to AWS resources. This is where IAM roles comes into play and allow you to delegate access to users or services, IAM Roles are intended to be assumable by anyone who needs it including IAM users, AWS services including machines and applications in our case. One can assume a role to obtain temporary security credentials that can be used to make AWS API calls. Note that IAM roles are not associated with a specific user or group, instead a trusted entities assume the roles, such as IAM users, applications, or AWS services. The best part of IAM Role is that you don’t have to share long-term credentials or define permissions for each entity that requires access to a resource. Isn’t that cool?

IAM Policy

Now that we understand an IAM Role, but how do we write rules etc for that role? This is where IAM Policy comes in, a policy is an object with identity or resource, defining their permissions one can also associate with 1-N Roles of a policy. Best practices is to use multiple policy since they are free. AWS IAM evaluates the policies when an IAM principal (a user, role, or group) makes a request. Permissions in the policies attached to the entity determine whether the request is allowed or denied. Policies are writting in json format, and one tip is when you are reading a policy always use the EPRAC format to evaluate it.

E is for Effect of the policy
P is for Principle of the policy (a user, role, or group)
R is for Resources of the policy (a service etc)
A is for Action of the policy (Allow or deny)
C is for Conditions of the policy, matching some condition ip address or require MFA etc

(For more info read: https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html)

Two types of policies

There are two types of policies one is managed policy and also an inline policy.

Managed Policy – has a name and can be attach to multiple users, group or roles. Think shareable policy, AWS has predefined policy in the system already that one can use.
Inline Policy – a policy that is embedded in an IAM identity (a user, role, or group) only, you cannot share it.

Show me some code now please

Sorry to bore you with all the details but those roles and policy are important and when things don’t work they could be culprits of them. But in any case we will be adding IAM to our solution now, check out the diagram below. You will notice that IAM is outside our VPC, since IAM is a global service it will be out side and we will attach the role inside to the EC2 machine in our later post.

AWS CDK IAM Role

Now our stack we will look like this now

using Amazon.CDK;
using Amazon.CDK.AWS.EC2;
using Amazon.CDK.AWS.IAM;
using Amazon.CDK.AWS.RDS;
using Amazon.CDK.AWS.SSM;

namespace CdkIAMSample
{
    public class CdkIAMSampleStack : Stack
    {
        internal CdkIAMSampleStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
            var vpc = new Vpc(this, "MyVpcSample", new VpcProps
            {
                Cidr = "10.0.0.0/16",
                MaxAzs = 2,
                SubnetConfiguration = new ISubnetConfiguration[]
                {
                    new SubnetConfiguration
                    {
                        CidrMask = 24,
                        SubnetType = SubnetType.PUBLIC,
                        Name = "MyPublicSubnet"
                    },
                    new SubnetConfiguration
                    {
                        CidrMask = 24,
                        SubnetType = SubnetType.PRIVATE,
                        Name = "MyPrivateSubnet"
                    }
                }
            });

            // Create the database
            const int dbPort = 1433;
            
            var db = new DatabaseInstance(this, "DB", new DatabaseInstanceProps
            {
                Vpc = vpc,
                VpcSubnets = new SubnetSelection{ SubnetType = SubnetType.PRIVATE },
                Engine = DatabaseInstanceEngine.SqlServerEx(new SqlServerExInstanceEngineProps { Version = SqlServerEngineVersion.VER_14 }),
                InstanceType = InstanceType.Of(InstanceClass.BURSTABLE2, InstanceSize.MICRO),
                Port = dbPort,
                InstanceIdentifier = "MyDbInstance",
                BackupRetention = Duration.Seconds(0) //not a good idea in prod, for sample it's ok
            });

            _ = new StringParameter(this, "DbSecretsParameter", new StringParameterProps
            {
                Description = "This is the dev env db secret name",
                ParameterName = "/myvpcsampledev/dbsecretsname",
                StringValue = db.Secret.SecretName
            });


            //Create the IAM role
            var appRole = new Role(this, "InstanceRole", new RoleProps
            {
                AssumedBy = new ServicePrincipal("ec2.amazonaws.com"),
                ManagedPolicies = new[]
                {
                    ManagedPolicy.FromAwsManagedPolicyName("AmazonSSMManagedInstanceCore"),
                    ManagedPolicy.FromAwsManagedPolicyName("service-role/AWSCodeDeployRole")
                }
            });

            //attach an inline policy
            appRole.AddToPolicy(new PolicyStatement(new PolicyStatementProps
            {
                Effect = Effect.ALLOW,
                Actions = new[] { "ssm:GetParametersByPath" },
                Resources = new[]
                {
                    Arn.Format(new ArnComponents
                    {
                        Service = "ssm",
                        Resource = "parameter",
                        ResourceName = "myvpcsampledev/*"
                    }, this)
                }
            }));

            //grant the read to the app Role
            db.Secret.GrantRead(appRole);
        }
    }
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

using Amazon.CDK;

using Amazon.CDK.AWS.EC2;

using Amazon.CDK.AWS.IAM;

using Amazon.CDK.AWS.RDS;

using Amazon.CDK.AWS.SSM;

namespace CdkIAMSample

{

public class CdkIAMSampleStack : Stack

{

internal CdkIAMSampleStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)

{

var vpc = new Vpc(this, "MyVpcSample", new VpcProps

{

Cidr = "10.0.0.0/16",

MaxAzs = 2,

SubnetConfiguration = new ISubnetConfiguration[]

{

new SubnetConfiguration

{

CidrMask = 24,

SubnetType = SubnetType.PUBLIC,

Name = "MyPublicSubnet"

},

new SubnetConfiguration

{

CidrMask = 24,

SubnetType = SubnetType.PRIVATE,

Name = "MyPrivateSubnet"

}

});

// Create the database

const int dbPort = 1433;

var db = new DatabaseInstance(this, "DB", new DatabaseInstanceProps

{

Vpc = vpc,

VpcSubnets = new SubnetSelection{ SubnetType = SubnetType.PRIVATE },

Engine = DatabaseInstanceEngine.SqlServerEx(new SqlServerExInstanceEngineProps { Version = SqlServerEngineVersion.VER_14 }),

InstanceType = InstanceType.Of(InstanceClass.BURSTABLE2, InstanceSize.MICRO),

Port = dbPort,

InstanceIdentifier = "MyDbInstance",

BackupRetention = Duration.Seconds(0) //not a good idea in prod, for sample it's ok

});

_ = new StringParameter(this, "DbSecretsParameter", new StringParameterProps

{

Description = "This is the dev env db secret name",

ParameterName = "/myvpcsampledev/dbsecretsname",

StringValue = db.Secret.SecretName

});

//Create the IAM role

var appRole = new Role(this, "InstanceRole", new RoleProps

{

AssumedBy = new ServicePrincipal("ec2.amazonaws.com"),

ManagedPolicies = new[]

{

ManagedPolicy.FromAwsManagedPolicyName("AmazonSSMManagedInstanceCore"),

ManagedPolicy.FromAwsManagedPolicyName("service-role/AWSCodeDeployRole")

}

});

//attach an inline policy

appRole.AddToPolicy(new PolicyStatement(new PolicyStatementProps

{

Effect = Effect.ALLOW,

Actions = new[] { "ssm:GetParametersByPath" },

Resources = new[]

{

Arn.Format(new ArnComponents

{

Service = "ssm",

Resource = "parameter",

ResourceName = "myvpcsampledev/*"

}, this)

}

}));

//grant the read to the app Role

db.Secret.GrantRead(appRole);

}

Build and Deploy

We will again use our good old trusty cdk to deploy the solution.

$dotnet build src
$cdk deploy

1 2	$dotnet build src $cdk deploy

If we check our console we can go to IAM and look at Roles and search for Instance in the search box. You will see something like this depending on your stack name etc.

Cdk Instance Role Generated

If we go into the role you look at the permission we will see an inline policy also attached to the role.

Cdk Instance Role Policy Genearted

Challenges

How do we add/create a managed policy using the CDK?
How do we add a principle to our policy using the CDK?
How do we add a condition to our policy using the CDK?

Summary

I know its a bit boring and dry for IAM but trust me its an important building block of AWS, we went through knowing more about Roles and Policy and how to use AWS CDK to create IAM roles with C#. In our next section I will cover how to create auto scaling groups for our EC2 machines.

Source code: https://github.com/taswar/AWSCDKSamples/tree/main/CdkIAMSample

.NET, AWS, CDK

aws, C#, cdk, iam

Using AWS CDK Parameter Store with C#

Taswar Bhatti April 15, 2021 No Comments

In this section we will talk about Parameter Store what it is and why we would want to use it? I will show you an example of using AWS CDK Parameter Store with C# and extending our current solution.

What is Parameter Store

AWS Parameter Store is actually a capability of AWS Systems Manager. The AWS Parameter store provides secure, hierarchical storage for configuration data management and secrets management. One can store data such as database connection strings, passwords, Amazon Machine Image (AMI) IDs, or even license codes as parameter values. There is also one additional advantage in parameter store where you can store values as plain text or encrypted data since it is also integrated with Secret Manager.
For more info on Parameter Store you can view the AWS Documentation (https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html)

Why would I want to use it?

From our previous deployment using CDK we saw that the db secret was stored in secret manager but it was a random string that was created something along the line of DBSecretB45K907. When we have multiple environment let’s say staging, testing and prod it will be hard to tell which one is which, since the dbsecrets will all have some random characters in their name, this is where Parameter comes and help. We can store the values in a path like format. e.g /myvpcsampledev/dbsecretsname. Now whenever we need to get the value of the dbsecret in our dev environment we can just refer to parameter store which will in turn use the Secret Manager. Make sense?

There are also additional advantages of Parameter Store

Store configuration data and encrypted strings in hierarchies and track versions.
Use a secure, scalable, hosted secrets management service with no servers to manage.
Improve your security posture by separating your data from your code.
Control and audit access at granular levels.
Store parameters reliably because Parameter Store is hosted in multiple Availability Zones in an AWS Region.

Now I hope you are sold on the idea 🙂 Let’s see how we use it in our CDK code to use Parameter store, later on we will use the same store to get the values.

Side note

Tier: Parameter Store provides two parameter tiers – standard and advanced. While standard tier lets you store up to 10,000 parameters and 4 KB per parameter in value size, advanced tier lets you store up to 100,000 parameters, 8 KB per parameter in value size and allows you to add policies to parameters.

Show me the code

Before showing the nitty gritty details of the code. Let’s see a diagram of what we are building and what we have added.

CDK ParameterStore

As you may wonder the parameter store and secret manager are not in your VPC. The reason is Parameter Store and Secret Manager are global services where they are hosted in multiple regions so think of it as a service you are consuming just like S3 etc rather than having everything inside your VPC. Now let’s look at the code and see what we will add to our Stack.

using Amazon.CDK;
using Amazon.CDK.AWS.EC2;
using Amazon.CDK.AWS.RDS;
using Amazon.CDK.AWS.SSM;

namespace CdkRDSParameterSample
{
    public class CdkRDSParameterSampleStack : Stack
    {
        internal CdkRDSParameterSampleStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
            var vpc = new Vpc(this, "MyVpcSample", new VpcProps
            {
                Cidr = "10.0.0.0/16",
                MaxAzs = 2,
                SubnetConfiguration = new ISubnetConfiguration[]
                {
                    new SubnetConfiguration
                    {
                        CidrMask = 24,
                        SubnetType = SubnetType.PUBLIC,
                        Name = "MyPublicSubnet"
                    },
                    new SubnetConfiguration
                    {
                        CidrMask = 24,
                        SubnetType = SubnetType.PRIVATE,
                        Name = "MyPrivateSubnet"
                    }
                }
            });

            const int dbPort = 1433;
            
            var db = new DatabaseInstance(this, "DB", new DatabaseInstanceProps
            {
                Vpc = vpc,
                VpcSubnets = new SubnetSelection{ SubnetType = SubnetType.PRIVATE },
                Engine = DatabaseInstanceEngine.SqlServerEx(new SqlServerExInstanceEngineProps { Version = SqlServerEngineVersion.VER_14 }),
                InstanceType = InstanceType.Of(InstanceClass.BURSTABLE2, InstanceSize.MICRO),
                Port = dbPort,
                InstanceIdentifier = "MyDbInstance",
                BackupRetention = Duration.Seconds(0) //not a good idea in prod, for sample it's ok
            });

            _ = new StringParameter(this, "DbSecretsParameter", new StringParameterProps
            {
                Description = "This is the dev env db secret name",
                ParameterName = "/myvpcsampledev/dbsecretsname",
                StringValue = db.Secret.SecretName
            });
        }
    }
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

using Amazon.CDK;

using Amazon.CDK.AWS.EC2;

using Amazon.CDK.AWS.RDS;

using Amazon.CDK.AWS.SSM;

namespace CdkRDSParameterSample

{

public class CdkRDSParameterSampleStack : Stack

{

internal CdkRDSParameterSampleStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)

{

var vpc = new Vpc(this, "MyVpcSample", new VpcProps

{

Cidr = "10.0.0.0/16",

MaxAzs = 2,

SubnetConfiguration = new ISubnetConfiguration[]

{

new SubnetConfiguration

{

CidrMask = 24,

SubnetType = SubnetType.PUBLIC,

Name = "MyPublicSubnet"

},

new SubnetConfiguration

{

CidrMask = 24,

SubnetType = SubnetType.PRIVATE,

Name = "MyPrivateSubnet"

}

});

const int dbPort = 1433;

var db = new DatabaseInstance(this, "DB", new DatabaseInstanceProps

{

Vpc = vpc,

VpcSubnets = new SubnetSelection{ SubnetType = SubnetType.PRIVATE },

Engine = DatabaseInstanceEngine.SqlServerEx(new SqlServerExInstanceEngineProps { Version = SqlServerEngineVersion.VER_14 }),

InstanceType = InstanceType.Of(InstanceClass.BURSTABLE2, InstanceSize.MICRO),

Port = dbPort,

InstanceIdentifier = "MyDbInstance",

BackupRetention = Duration.Seconds(0) //not a good idea in prod, for sample it's ok

});

_ = new StringParameter(this, "DbSecretsParameter", new StringParameterProps

{

Description = "This is the dev env db secret name",

ParameterName = "/myvpcsampledev/dbsecretsname",

StringValue = db.Secret.SecretName

});

}

Note: ParameterName always starts with a / in front of it.

As you can see above we have just added a string parameter and we have used the db.Secret.SecretName as a StringValue inside of Parameter Store. What is left is for us to build and deploy the solution just like our previous solution with dotnet and cdk.

$ dotnet build src
$ cdk deploy

1 2	$ dotnet build src $ cdk deploy

Once deployed lets look at the console to see how it would look like. Navigate to your CloudFormation screen on AWS Console, click on resources tab and from there find the Parameter store created link. Click on the link and you should be redirected to parameter store and you should see something like below.

ParameterStoreDbSecret

Challenges

What happens when you change the parameter type to an encrypted (secure) string. Can you use SecretString?
What about SimpleValue, what are the differences?
What about StringListValue, what are the differences?
Can we use pattern matching for the ParameterName? (Hint: look at AllowedPattern)
What other attributes can we store in the parameter store for our db object we created

Summary

In the above example we saw how to use Parameter store with our CDK code, in the next section we will cover IAM roles and how we will use them to attach roles to our EC2 machine and database, think of it as a glue to allow security and access permission.

Source code (https://github.com/taswar/AWSCDKSamples/tree/main/CdkRDSParameterSample)

.NET, AWS, C#, CDK

cdk, csharp

Using AWS CDK to create RDS Database Instance with C#

Taswar Bhatti April 12, 2021 No Comments

Now that we have learned how to create a VPC with C# using AWS CDK, let’s talk about how do we create RDS Database Instance with C# using AWS CDK.

What is Amazon RDS?

Amazon Relational Database Service (Amazon RDS) in simple terms is easy to set up, operate, and scale relational database. It provides cost-efficient and resizable capacity while automating time-consuming administration tasks such as hardware provisioning, database setup, patching and backups. When we use Amazon RDS, we can set up, operate, and scale a relational database in the cloud. Amazon RDS also supports several different database engines, including PostgreSQL, MySQL, Oracle, and Microsoft SQL Server.

What do we plan to build?

We will be using Microsoft SQL Server instance in the example below, you can use any other RDS instance of your choice also, but I thought SQL Server would be ideal for .NET developer. Supported Databases include MariaDB, Microsoft SQLServer, Postgres, MySQL and Oracle. For more information refer to (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.DBInstanceClass.html#Concepts.DBInstanceClass.Support)

The architectural diagram below shows that we will place our primary database instance in Availability Zone A inside the private subnet. Amazon RDS requires at least two Availability Zones for fault tolerance, but since we are using Microsoft SQL Server Express engine it doesn’t create a secondary instance.

VPC-subnet-RDS

Tip: When deploying an application in production environment always create a secondary Amazon RDS DB instance in another Availability Zone.

Where is the code

We will first need to use Nuget to install Amazon.CDK.AWS.RDS package. We can either use Visual Studio or the command line to install it into our project. Make sure to have the latest version of it.

PM> Install-Package Amazon.CDK.AWS.RDS

1	PM> Install-Package Amazon.CDK.AWS.RDS

Once installed you can add this code into your Stack class file. In our code based it will be CdkRDSSampleStack.cs.

using Amazon.CDK;
using Amazon.CDK.AWS.EC2;
using Amazon.CDK.AWS.RDS;

namespace CdkRDSSample
{
    public class CdkRDSSampleStack : Stack
    {
        internal CdkRDSSampleStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
            var vpc = new Vpc(this, "MyVpcSample", new VpcProps
            {
                Cidr = "10.0.0.0/16",
                MaxAzs = 2,
                SubnetConfiguration = new ISubnetConfiguration[]
                {
                    new SubnetConfiguration
                    {
                        CidrMask = 24,
                        SubnetType = SubnetType.PUBLIC,
                        Name = "MyPublicSubnet"
                    },
                    new SubnetConfiguration
                    {
                        CidrMask = 24,
                        SubnetType = SubnetType.PRIVATE,
                        Name = "MyPrivateSubnet"
                    }
                }
            });

            const int dbPort = 1433;
            
            var db = new DatabaseInstance(this, "DB", new DatabaseInstanceProps
            {
                Vpc = vpc,
                VpcSubnets = new SubnetSelection{ SubnetType = SubnetType.PRIVATE },
                Engine = DatabaseInstanceEngine.SqlServerEx(new SqlServerExInstanceEngineProps { Version = SqlServerEngineVersion.VER_14 }),
                InstanceType = InstanceType.Of(InstanceClass.BURSTABLE2, InstanceSize.MICRO),
                Port = dbPort,
                InstanceIdentifier = "MyDbInstance",
                BackupRetention = Duration.Seconds(0) //not a good idea in prod, for this sample code it's ok
            });
        }
    }
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

using Amazon.CDK;

using Amazon.CDK.AWS.EC2;

using Amazon.CDK.AWS.RDS;

namespace CdkRDSSample

{

public class CdkRDSSampleStack : Stack

{

internal CdkRDSSampleStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)

{

var vpc = new Vpc(this, "MyVpcSample", new VpcProps

{

Cidr = "10.0.0.0/16",

MaxAzs = 2,

SubnetConfiguration = new ISubnetConfiguration[]

{

new SubnetConfiguration

{

CidrMask = 24,

SubnetType = SubnetType.PUBLIC,

Name = "MyPublicSubnet"

},

new SubnetConfiguration

{

CidrMask = 24,

SubnetType = SubnetType.PRIVATE,

Name = "MyPrivateSubnet"

}

});

const int dbPort = 1433;

var db = new DatabaseInstance(this, "DB", new DatabaseInstanceProps

{

Vpc = vpc,

VpcSubnets = new SubnetSelection{ SubnetType = SubnetType.PRIVATE },

Engine = DatabaseInstanceEngine.SqlServerEx(new SqlServerExInstanceEngineProps { Version = SqlServerEngineVersion.VER_14 }),

InstanceType = InstanceType.Of(InstanceClass.BURSTABLE2, InstanceSize.MICRO),

Port = dbPort,

InstanceIdentifier = "MyDbInstance",

BackupRetention = Duration.Seconds(0) //not a good idea in prod, for this sample code it's ok

});

}

In order for us to deploy this code we will again use the command line with cdk to deploy it. You may wonder where will the login and password be for the database, we will talk about that shortly. Remember to have your aws login pre-configured or else cdk deploy will fail, refer to the previous Creating VPC for additional information.

$ dotnet build src
$ cdk deploy

1 2	$ dotnet build src $ cdk deploy

Viewing your information in the AWS Console

Once the cdk process is finished we can login to our AWS console to see what has been deployed so far. Go into the cloudformation section and we should see that our stack should have a CREATE_COMPLETE status like below.

RDS-stack-created

We can then go into the Resource section of the stack and see that our DBSecret for the database has been created and it is actually using AWS SecretManager that contains the details of the login and password. We can also go to our database section in RDS and see our instance is up and running. We will not be able to connect to it from our desktop since it is in a private network and public connection accessibility is set to No.

RDS-SQLServer-MyInstance

Challenges

What if you try to use a different database engine, e.g MariaDB or Postgres what would you change in your code?
What happens when you change the current SQLServer to another version?
The current machine is not powerful for sqlserver. what other instance type are supported to run this?

Summary

This shows how we can easily use AWS CDK to create RDS Database Instance with C#, in the next part we will go over System Manager Parameter Store that one can use to store configurations.

Source code: (https://github.com/taswar/AWSCDKSamples/tree/main/CdkRDSSample)

.NET, AWS, C#, CDK

aws, C#, cdk, csharp

Using AWS CDK to create a VPC in C#

Taswar Bhatti April 7, 2021 No Comments

I wanted to start a series of how to use AWS Cloud Development Kit (CDK) to create infrastructure on Amazon. In our first example we will tackle the fundamental of a Virtual Private Cloud (VPC). We will be using AWS CDK to create a VPC in C#. You may wonder what about CloudFormation json or yaml files that Amazon allows one to create infrastructure that you maybe very comfortable in doing it, is CDK replacing that?

What about CloudFormation?

AWS CloudFormation enables you to do many things, below are some of the things that the CDK allows us to do. (https://docs.aws.amazon.com/cdk/latest/guide/home.html)

Create and provision AWS infrastructure deployments predictably and repeatedly.
Leverage AWS products such as Amazon EC2, Amazon Elastic Block Store, Amazon SNS, Elastic Load Balancing, and Auto Scaling.
Build highly reliable, highly scalable, cost-effective applications in the cloud without worrying about creating and configuring the underlying AWS infrastructure.
Use a template file to create and delete a collection of resources together as a single unit (a stack).

Rest assure that Cloudformation is here to stay and CDK is not a way to replace it, but think of it in terms of a SDK for you to create infrastructure in the language of your choice.

Ok tell me more about CDK?

The advantage of AWS CDK is that you can define your cloud resources in a familiar programming language. As it stands the AWS CDK supports TypeScript, JavaScript, Python, Java, C#/.Net, and (in developer preview) Go lang. As a developers you can use one of the supported programming languages to define reusable cloud components known as Constructs. You compose these together into Stacks and Apps. The other advantages of the AWS CDK include listed below:

Use logic (if statements, for-loops, etc) when defining your infrastructure
Use object-oriented techniques to create a model of your system
Define high level abstractions, share them, and publish them to your team, company, or community
Organize your project into logical modules
Share and reuse your infrastructure as a library
Testing your infrastructure code using industry-standard protocols
Use your existing code review workflow
Code completion within your IDE

More information at (https://docs.aws.amazon.com/cdk/latest/guide/home.html)

What is an Amazon Virtual Private Cloud (VPC)?

Before we get started I wanted to provide some information on VPC. With Amazon Virtual Private Cloud (Amazon VPC), you can launch AWS resources in a logically isolated virtual network that you define. You have complete control over your virtual networking environment. This includes selecting your own IP address range, creating subnets, and configuring route tables and network gateways. And the reason to use a VPC is that your applications and database will be accessible over the network, but you may not want them to be accessible to everyone over the internet. Using an Amazon VPC, you can control who accesses which resources over the network.

Show me what we are building

The diagram below shows us the VPC that contains two Availability Zones, and in each one you will see there are 2 subnets a public and a private subnet. The public subnet will allow internet traffic while the private will not.

Usually you want to put your infra in private and only allow certain traffic to go through and reach them through the public

VPC-subnet

Requirements for CDK

In order to work with the cdk we will need 2 things, nodejs and the other is of course .NET 5 or 6. If you have nodejs and .net 5 or 6 ready then all you have to do is open your command line terminal and execute the following command to install cdk.

$npm install -g aws-cdk

1	$npm install -g aws-cdk

Now that the cdk is ready lets create a directory and intiliaze our application creation.

$mkdir CdkVpcSample
$cd CdkVpcSample
$cdk init app --language csharp
# Welcome to your CDK C# project!

This is a blank project for C# development with CDK.

The `cdk.json` file tells the CDK Toolkit how to execute your app.

It uses the [.NET Core CLI](https://docs.microsoft.com/dotnet/articles/core/) to compile and execute your project.

## Useful commands

* `dotnet build src` compile this app
* `cdk deploy`       deploy this stack to your default AWS account/region
* `cdk diff`         compare deployed stack with current state
* `cdk synth`        emits the synthesized CloudFormation template

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

$mkdir CdkVpcSample

$cd CdkVpcSample

$cdk init app --language csharp

# Welcome to your CDK C# project!

This is a blank project for C# development with CDK.

The `cdk.json` file tells the CDK Toolkit how to execute your app.

It uses the [.NET Core CLI](https://docs.microsoft.com/dotnet/articles/core/) to compile and execute your project.

## Useful commands

* `dotnet build src` compile this app

* `cdk deploy` deploy this stack to your default AWS account/region

* `cdk diff` compare deployed stack with current state

* `cdk synth` emits the synthesized CloudFormation template

Lets take a look at what was created.

Below we have a list of generated application has created.

A cdk.json file, with AWS CDK configuration
A README.md file with some documentation that you may add for your project
A src folder with the C# application

A CdkVpcSample folder with the generated C# code
Program.cs contains the main file., where we define how we will connect to our cloud env.
CdkVpcSampleStack.cs contains the code for one CloudFormation stack (a stack is a collection of AWS resources that you can manage as a single unit), we use this to create the stack that we want.
CdkVpcSample.csproj is the project file.
GlobalSuppressions.cs deactivates one compiler warning.

Last but not least the solution file, CdkVpcSample.sln

│   .gitignore
│   cdk.json
│   README.md
│
└───src
    │   CdkVpcSample.sln
    │
    └───CdkVpcSample
            CdkVpcSample.csproj
            CdkVpcSampleStack.cs
            GlobalSuppressions.cs
            Program.cs

1

2

3

4

5

6

7

8

9

10

11

12

│ .gitignore

│ cdk.json

│ README.md

│

└───src

│ CdkVpcSample.sln

│

└───CdkVpcSample

CdkVpcSample.csproj

CdkVpcSampleStack.cs

GlobalSuppressions.cs

Program.cs

We can now open the sln file in our visual studio and lets modify the Program.cs file. We will modify the code to use the Account Id that you have for AWS and also the Region you plan to use. If you wish to use Env variables you can use the first block also. For simplicity sake I am using the second block to target only the region I plan to use.

 sealed class Program
    {
        public static void Main(string[] args)
        {
            var app = new App();
            new CdkVpcSampleStack(app, "CdkVpcSampleStack", new StackProps
            {
                // If you don't specify 'env', this stack will be environment-agnostic.
                // Account/Region-dependent features and context lookups will not work,
                // but a single synthesized template can be deployed anywhere.

                // Uncomment the next block to specialize this stack for the AWS Account
                // and Region that are implied by the current CLI configuration.
                /*
                Env = new Amazon.CDK.Environment
                {
                    Account = System.Environment.GetEnvironmentVariable("CDK_DEFAULT_ACCOUNT"),
                    Region = System.Environment.GetEnvironmentVariable("CDK_DEFAULT_REGION"),
                }
                */

                // Uncomment the next block if you know exactly what Account and Region you
                // want to deploy the stack to.
                
                Env = new Amazon.CDK.Environment
                {
                    Account = "123456789012", //fill in your account here
                    Region = "us-east-1", //fill in the region you plan to use
                }
                

                // For more information, see https://docs.aws.amazon.com/cdk/latest/guide/environments.html
            });

            app.Synth();
        }
    }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

sealed class Program

{

public static void Main(string[] args)

{

var app = new App();

new CdkVpcSampleStack(app, "CdkVpcSampleStack", new StackProps

{

// If you don't specify 'env', this stack will be environment-agnostic.

// Account/Region-dependent features and context lookups will not work,

// but a single synthesized template can be deployed anywhere.

// Uncomment the next block to specialize this stack for the AWS Account

// and Region that are implied by the current CLI configuration.

/*

Env = new Amazon.CDK.Environment

{

Account = System.Environment.GetEnvironmentVariable("CDK_DEFAULT_ACCOUNT"),

Region = System.Environment.GetEnvironmentVariable("CDK_DEFAULT_REGION"),

}

*/

// Uncomment the next block if you know exactly what Account and Region you

// want to deploy the stack to.

Env = new Amazon.CDK.Environment

{

Account = "123456789012", //fill in your account here

Region = "us-east-1", //fill in the region you plan to use

}

// For more information, see https://docs.aws.amazon.com/cdk/latest/guide/environments.html

});

app.Synth();

}

Now we can jump into CdkVpcSampleStack.cs file and add the code we wish to create the vpc. We will also use nuget to install the Amazon.CDK.AWS.EC2 package.
You can also just use Visual Studio and add the package through the UI, just search Amazon.CDK.AWS.EC2 and click on install.

PM> Install-Package Amazon.CDK.AWS.EC2

1	PM> Install-Package Amazon.CDK.AWS.EC2

Below is the vpc code that we will add to our CdkVpcSampleStack.cs file. Below we are creating a VPC with a CIDR 10.0.0.0/16 and 2 subnet one is public subnet with CIDR Mask of 24 and a private with a CIDR Mask of 24.

using Amazon.CDK;
using Amazon.CDK.AWS.EC2;

namespace CdkVpcSample
{
    public class CdkVpcSampleStack : Stack
    {
        internal CdkVpcSampleStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
            var vpc = new Vpc(this, "MyVpcSample", new VpcProps
            {
                Cidr = "10.0.0.0/16",
                MaxAzs = 2,
                SubnetConfiguration = new ISubnetConfiguration[]
                {
                    new SubnetConfiguration
                    {
                        CidrMask = 24,
                        SubnetType = SubnetType.PUBLIC,
                        Name = "MyPublicSubnet"
                    },
                    new SubnetConfiguration
                    {
                        CidrMask = 24,
                        SubnetType = SubnetType.PRIVATE,
                        Name = "MyPrivateSubnet"
                    }
                }
            });
        }
    }
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

using Amazon.CDK;

using Amazon.CDK.AWS.EC2;

namespace CdkVpcSample

{

public class CdkVpcSampleStack : Stack

{

internal CdkVpcSampleStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)

{

var vpc = new Vpc(this, "MyVpcSample", new VpcProps

{

Cidr = "10.0.0.0/16",

MaxAzs = 2,

SubnetConfiguration = new ISubnetConfiguration[]

{

new SubnetConfiguration

{

CidrMask = 24,

SubnetType = SubnetType.PUBLIC,

Name = "MyPublicSubnet"

},

new SubnetConfiguration

{

CidrMask = 24,

SubnetType = SubnetType.PRIVATE,

Name = "MyPrivateSubnet"

}

});

}

Let’s now try to build the project going to the root directory where src directory is and type in command line

$ dotnet build src

1	$ dotnet build src

Remember to target to .NET 5 or 6, you can change that in Visual Studio by right click and properties section.

How do deploy

In order to deploy first you will need a user who has programmatic access to your aws account. Reach into the IAM service on AWS console and create a user. You can read my other IAM post on how to create a user.

Once created you can use aws cli to configure the user you will use like below I have used an access key id and secret access for it.

PS C:> & 'C:\Program Files\Amazon\AWSCLIV2\aws.exe' configure
AWS Access Key ID [None]: XYZS3CMdsgfdshdshdshggfdsdsgf
AWS Secret Access Key [None]: z/DZTQpT6Zaasfdasfdasgasgdhfertdgf
Default region name [None]: eu-central-1
Default output format [None]: json

1

2

3

4

5

PS C:> & 'C:\Program Files\Amazon\AWSCLIV2\aws.exe' configure

AWS Access Key ID [None]: XYZS3CMdsgfdshdshdshggfdsdsgf

AWS Secret Access Key [None]: z/DZTQpT6Zaasfdasfdasgasgdhfertdgf

Default region name [None]: eu-central-1

Default output format [None]: json

Now you can finally deploy with cdk using the cdk deploy command.

Warning: This may incur AWS charges

If you now login to the AWS console you will see in Cloudformation section that your Stack was created, and also in your VPC section the VPC was create with public and private subnet.

Challenges

How to destroy the stack can you use cdk?
What happens when you do cdk deploy again
Change the Subnet CIDR to a different range
Play around with the MaxAzs option

Summary

I hope this helps in teaching and learning how to deploy a VPC using AWS CDK to create a VPC in C#, we will continue on with explorer more on CDK with .NET in the following with AWS RDS Database.

Source code located at https://github.com/taswar/AWSCDKSamples/tree/main/CdkVpcSample

.NET, AWS, CDK

aws, C#, cdk

Setup Brother 1110 Printer on Raspberry Pi as Network Printer

Taswar Bhatti April 5, 2021 2 Comments

I had this printer which is not a wifi built-in printer but nevertheless its a laser printer and I wanted to use it to print from any machine on my local network. I thought to myself why not use a raspberry pi and use cups. Thus my post on how to Setup Brother 1110 Printer on Raspberry Pi, I actually reuse the pi I had that is running pihole to block all the ads coming into my home network. Long story short I thought CUPS would be easy to setup and hoped everything will work, well of course things don’t just work without me tinkering on it, so here are the steps I used to finally to get it to work and hopefully it may help you also in your journey 🙂

First things first what is CUPS?

CUPS is a modular printing system for Unix-like computer operating systems which allows a computer to act as a print server. To install CUPS on a PI you can use the commands below.

Install cups and drivers from the Brother website
Login to your pi

pi@raspberrypi:~/ $ sudo apt-get update
pi@raspberrypi:~/ $ sudo apt-get upgrade
pi@raspberrypi:~/ $ sudo apt-get install qemu binfmt-support qemu-user-static cups a2ps

1

2

3

pi@raspberrypi:~/ $ sudo apt-get update

pi@raspberrypi:~/ $ sudo apt-get upgrade

pi@raspberrypi:~/ $ sudo apt-get install qemu binfmt-support qemu-user-static cups a2ps

Brother only provides i386 driver but as you may know Pi is a Arm processor so we need to somehow get them to work but first lets download the deb packages.

pi@raspberrypi:~/ $ mkdir driver
pi@raspberrypi:~/ $ cd driver
pi@raspberrypi:~/driver $ wget http://download.brother.com/welcome/dlf100419/hl1110lpr-3.0.1-1.i386.deb
pi@raspberrypi:~/driver $ wget http://download.brother.com/welcome/dlf100421/hl1110cupswrapper-3.0.1-1.i386.deb

1

2

3

4

pi@raspberrypi:~/ $ mkdir driver

pi@raspberrypi:~/ $ cd driver

pi@raspberrypi:~/driver $ wget http://download.brother.com/welcome/dlf100419/hl1110lpr-3.0.1-1.i386.deb

pi@raspberrypi:~/driver $ wget http://download.brother.com/welcome/dlf100421/hl1110cupswrapper-3.0.1-1.i386.deb

We will also add the architecture

pi@raspberrypi:~/driver $ sudo dpkg --add-architecture i386

1	pi@raspberrypi:~/driver $ sudo dpkg --add-architecture i386

We will also need to use Kali linux libc6 in order for this to work.

pi@raspberrypi:~/driver $ wget old.kali.org/kali-security/pool/main/e/eglibc/libc6_2.13-38+deb7u8_i386.deb

1	pi@raspberrypi:~/driver $ wget old.kali.org/kali-security/pool/main/e/eglibc/libc6_2.13-38+deb7u8_i386.deb

We will then extract the libc into a directory so that we dont need to mess with apt and then copy them over.

pi@raspberrypi:~/driver $ sudo dpkg -x libc6_2.13-38+deb7u8_i386.deb  data
pi@raspberrypi:~/driver $ cd data/
pi@raspberrypi:~/driver/data $ ls
etc  lib  usr

1

2

3

4

pi@raspberrypi:~/driver $ sudo dpkg -x libc6_2.13-38+deb7u8_i386.deb data

pi@raspberrypi:~/driver $ cd data/

pi@raspberrypi:~/driver/data $ ls

etc lib usr

As you can see above we have 3 directories etc, lib and usr extracted into data directory. Now we will copy them over.

pi@raspberrypi:~/driver/data $ cd ..
pi@raspberrypi:~/driver $ sudo cp -r data/lib/* /lib/
pi@raspberrypi:~/driver $ sudo cp -r data/usr/* /usr
pi@raspberrypi:~/driver $ sudo cp -r data/etc/* /etc

1

2

3

4

pi@raspberrypi:~/driver/data $ cd ..

pi@raspberrypi:~/driver $ sudo cp -r data/lib/* /lib/

pi@raspberrypi:~/driver $ sudo cp -r data/usr/* /usr

pi@raspberrypi:~/driver $ sudo cp -r data/etc/* /etc

We will also add this to our env variable to build and then we can install our packages. You can ignore the warning, also you will get this error in cups also when you print so you can ignore that also.

pi@raspberrypi:~/driver $ EXTRA_OPTS="-L /lib/i386-linux-gnu"
pi@raspberrypi:~/driver $ sudo dpkg -i hl1110lpr-3.0.1-1.i386.deb
Selecting previously unselected package hl1110lpr:i386.
(Reading database ... 162742 files and directories currently installed.)
Preparing to unpack hl1110lpr-3.0.1-1.i386.deb ...
Unpacking hl1110lpr:i386 (3.0.1-1) ...
Setting up hl1110lpr:i386 (3.0.1-1) ...
ERROR: ld.so: object '/usr/lib/arm-linux-gnueabihf/libarmmem-${PLATFORM}.so' from /etc/ld.so.preload cannot be preloaded: ignored.

1

2

3

4

5

6

7

8

pi@raspberrypi:~/driver $ EXTRA_OPTS="-L /lib/i386-linux-gnu"

pi@raspberrypi:~/driver $ sudo dpkg -i hl1110lpr-3.0.1-1.i386.deb

Selecting previously unselected package hl1110lpr:i386.

(Reading database ... 162742 files and directories currently installed.)

Preparing to unpack hl1110lpr-3.0.1-1.i386.deb ...

Unpacking hl1110lpr:i386 (3.0.1-1) ...

Setting up hl1110lpr:i386 (3.0.1-1) ...

ERROR: ld.so: object '/usr/lib/arm-linux-gnueabihf/libarmmem-${PLATFORM}.so' from /etc/ld.so.preload cannot be preloaded: ignored.

Now lets install the cups wrapper.

pi@raspberrypi:~/driver $ sudo dpkg -i hl1110cupswrapper-3.0.1-1.i386.deb
Selecting previously unselected package hl1110cupswrapper:i386.
(Reading database ... 162763 files and directories currently installed.)
Preparing to unpack hl1110cupswrapper-3.0.1-1.i386.deb ...
Unpacking hl1110cupswrapper:i386 (3.0.1-1) ...
Setting up hl1110cupswrapper:i386 (3.0.1-1) ...
lpadmin -p HL1110 -E -v usb://Brother/HL-1110%20series?serial=L0N818210 -P /usr/share/ppd/brother/brother-HL1110-cups-en.ppd

1

2

3

4

5

6

7

pi@raspberrypi:~/driver $ sudo dpkg -i hl1110cupswrapper-3.0.1-1.i386.deb

Selecting previously unselected package hl1110cupswrapper:i386.

(Reading database ... 162763 files and directories currently installed.)

Preparing to unpack hl1110cupswrapper-3.0.1-1.i386.deb ...

Unpacking hl1110cupswrapper:i386 (3.0.1-1) ...

Setting up hl1110cupswrapper:i386 (3.0.1-1) ...

lpadmin -p HL1110 -E -v usb://Brother/HL-1110%20series?serial=L0N818210 -P /usr/share/ppd/brother/brother-HL1110-cups-en.ppd

Finally we need to restart our cups server

pi@raspberrypi:~/driver $ sudo /etc/init.d/cups restart
[ ok ] Restarting cups (via systemctl): cups.service.

1 2	pi@raspberrypi:~/driver $ sudo /etc/init.d/cups restart [ ok ] Restarting cups (via systemctl): cups.service.

If you wish to manage cups with pi user use the commands below and then you can access cups with the web user interface on http://localhost:631

pi@raspberrypi:~/ $ sudo usermod -a -G lpadmin pi
pi@raspberrypi:~/ $ sudo cupsctl --remote-any
pi@raspberrypi:~/driver $ sudo /etc/init.d/cups restart
[ ok ] Restarting cups (via systemctl): cups.service.

1

2

3

4

pi@raspberrypi:~/ $ sudo usermod -a -G lpadmin pi

pi@raspberrypi:~/ $ sudo cupsctl --remote-any

pi@raspberrypi:~/driver $ sudo /etc/init.d/cups restart

[ ok ] Restarting cups (via systemctl): cups.service.

If you are using windows 10 you dont really need to install Samba you will be able to see your pi printer by just opening printer and add it will auto scan your network for it. Hopefully this will help you out and enjoyed reading How to setup Brother 1110 Printer on Raspberry Pi 🙂

Misc

brother, pi, printer, raspberry

Numerical Types

Summary

Intro

Summary

Intro

Getting input from terminal

Summary

Creating Rust test directory

Adding development dependency to Cargo.toml

let mut what is that?

Unwrap what is that?

Summary

Installing Rust

Simple Hello World

Creating and Running a Project with Cargo

What is this Cargo.toml

What about VSCode?

Install Rust Extension

Run Rust in VSCode

Summary

What is IAM?

Additional things IAM Allows

IAM Roles

IAM Policy

Two types of policies

Show me some code now please

Build and Deploy

Challenges

Summary

What is Parameter Store

Why would I want to use it?

Side note

Show me the code

Challenges

Summary

What is Amazon RDS?

What do we plan to build?

Where is the code

Viewing your information in the AWS Console

Challenges

Summary

What about CloudFormation?

Ok tell me more about CDK?

What is an Amazon Virtual Private Cloud (VPC)?

Show me what we are building

Requirements for CDK

Lets take a look at what was created.

How do deploy

Challenges

Summary

First things first what is CUPS?

Opinions are my own and not the views of my employer

LinkedIn

My Book

Archives