Forem: Andris Jansons

How I became AWS Certified

Andris Jansons — Tue, 05 Nov 2019 22:50:29 +0000

Where did it all start

I believe I first heard the phrase "AWS Certified" just 3 months ago. I was working with DevOps on AWS and managed to get my hands on a Pluralsight subscription. The first course I stumbled across was AWS Certified DevOps Engineer: Continuous Delivery and Automation. I had no interest in the certification part, what got me hooked was the Continuous Delivery and Automation.

Get certified?

A colleague of mine raised a question if I plan to get certified with that course? It took me a few days to realize that I was preparing for the highest level of AWS certification - Professional.

I've always looked down on certifications, thinking it's more of a gimmick. With so many certifications out there, you can't expect an HR manager to know if it validates your skill or your ability to recite a textbook.

Maybe it was time to shine a different light on the subject.

Benefits

I am studying for a Computer Science BSc and where do I deploy my university projects? - Cloud!
What about side projects? - Cloud!
Let's not forget Hackathons - Also Cloud!
I am freelancing as a Software Engineer and guess where I'm deploying the applications? - Cloud!
In my internship, I am working on rearchitecting legacy apps for Cloud!

Super early in my career and no matter what I do, it has something to do with the cloud. It just made sense to go out of my way and get a certification from the leading cloud provider AWS.

AWS Certification roadmap

I was willing to give certifications a try, but I wasn't going to dive deep into the highest level. No, if I want to do it right, I have to start with the Certified Cloud Practitioner, move on to Associate and finish with Professional.

Preparation

To prepare for the exam, I turned to A Cloud Guru (acloud.guru). They provide specialized certification training for AWS and Azure which they update every few months to reflect the newest changes. It's easy to follow along and has a variety of hands-on labs and lectures all split into small, easy to follow chunks of a few minutes each. But that's not it, they have practice exams that closely simulate the real exam experience and with complete explanations for every answer that you get wrong. Furthermore, there are weekly update videos of all the news on AWS and a massive collection of other cloud-related videos.

All I did was finished the 5 hour Cloud Practitioner course, read the whitepapers and did the practice exam until I felt ready.

Exam day

Just a month ago AWS announced that Certified Cloud Practitioner exam can be taken from home. That's how I took mine. Late in the evening at my own leisure. And to no surprise, it all went smooth. The questions were not easy, but that was expected as AWS exams are geared toward real-world situations rather than definitions.

Overall I was satisfied with the whole experience and even more so when I saw the word "Congratulations" appear when I finished the exam.

As of 5th November, 2019 I am now AWS Certified!

AWS - How to deny access to resources while allowing a specific role

Andris Jansons — Sat, 19 Oct 2019 22:02:14 +0000

TL;DR

To correctly use Deny effect together with NotPrincipal, instead of specifying the NotPrincipal, add a StringNotEquals condition for AWS:PrincipalARN. Skip to example.

The wrong way to use `"effect": "Deny"` with `"NotPrincipal"`

When it comes to granting permissions, it's as easy as allowing the required permissions for a specific role or user. However, it's not so easy when you're working in a shared account where others have the same access to your resources as you do.

Don't you hate when other users mess with your stuff or even worse - they accidentally expose their credentials and now the whole world has access to your S3 bucket... To avoid worrying, you thought it was a great idea to add a Deny policy to your resource, denying access to everyone but yourself.

The following is an example of how not to do it. Try to spot why. Scroll down for the correct way.

{ 
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Deny",
      "NotPrincipal": {
        "AWS": "arn:aws:iam::000000000000:role/<my-user-role>"
      },
      "Action": "s3:*",
      "Resource": "arn:aws:s3:::<my-bucket>/*"
    }
  ]
}

Good job, you've locked yourself out of your bucket! Nor you, the root account user nor anyone else will be able to do anything with the bucket, it is essentially rendered useless. While the above policy might look valid, the problem is that when a user/role performs an action, it's principal consists of the following:

"arn:aws:sts::000000000000:assumed-role/<my-user-role>/<instance-id>"
"arn:aws:iam::000000000000:role/<my-user-role>"
"arn:aws:iam::000000000000:root"

So when you set the Deny to ignore your role, it implicitly denied your assumed-role and root resulting in denying you access to your resource.

Could I not just add my assumed role and root to the exception list? You could... But for example, each Lambda function has a different assumed-role and you can't use wildcard characters in Principal values. I don't know about you, but when Amazon's official documentation on NotPrincipal recommends not to use it, I'd rather find a better way.

The correct ways

The slightly harder way

That involves calling aws sts get-caller-identity for every user, populating policies with ids that make no sense and doesn't really work with functional roles (unless you plan to invoke sts get-caller-identity from inside your lambda/ec2/etc)

I'll just refer you to AWS blog posts here and here.

The easy way (Recommended)

According to the AWS Global Condition Key documentation, there is a key called aws:PrincipalArn

Which is great, because:

It is always included in the request content;
It returns the ARN of the role instead of the assumed-role;
It supports wildcards;
Global Condition Keys are available for every action.

There is a mistake in the documentation, as aws:PrincipalArn does not work with ARN operators, instead, it works with String operators.

All of this means, that instead of using "NotPrincipal", we can specify a "StringNotEquals" condition on "aws:PrincipalArn" and specifying our roles ARN. Don't worry if you've never used a Condition before, pick one of the following examples and adapt it to your needs.

Allowing access only to a single ARN

{ 
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Deny",
      "Principal": "*",
      "Action": "s3:*",
      "Resource": "arn:aws:s3:::<my-bucket>/*",
      "Condition": {
        "StringNotEquals": {
          "aws:PrincipalArn": "arn:aws:iam::000000000000:role/<my-user-role>",
        }
      }
    }
  ]
}

Let's say we have different roles named:

my-project-lambda
my-project-ec2
my-project-console

We can use a placeholder (*) to select them all at the same time by using "StringNotLike" instead of "StringNotEquals"

Using placeholders

{ 
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Deny",
      "Principal": "*",
      "Action": "s3:*",
      "Resource": "arn:aws:s3:::<my-bucket>/*",
      "Condition": {
        "StringNotLike": {
          "aws:PrincipalArn": "arn:aws:iam::000000000000:role/my-project-*",
        }
      }
    }
  ]
}

Wanted just to benefit from "aws:PrincipalArn" without having to deny anything? Use it with allow in the same way!

Allowing with multiple roles

{ 
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": "*",
      "Action": "s3:*",
      "Resource": "arn:aws:s3:::<my-bucket>/*",
      "Condition": {
        "StringEquals": {
          "aws:PrincipalArn": [
            "arn:aws:iam::000000000000:role/<my-user-role>",
            "arn:aws:iam::000000000000:role/<my-manager-role>",
            "arn:aws:iam::000000000000:role/<my-audit-role>"
          ]
        }
      }
    }
  ]
}

This is most powerful when working in a corporate AWS account. Especially when there is a dedicated team managing Identity-based policies and roles, but developers themselves manage Resource-based policies. Sadly not all resources can have their own policies, a full list of those that can is available here.

That is all I wanted to share today, best of luck in your Cloud endeavors and let me know in the comments of all the resources you've locked yourself out of.

!Pokémon or (Not Pokémon)

Andris Jansons — Thu, 22 Mar 2018 00:50:01 +0000

Not Pokémon (Pun intended)

A managed C++ Windows Forms game as my university project.

By just showcasing this game in Computing, Electronics, and Mathematics Showcase NEW WIZARDS 2018, I wanted to put it here as well.

Over the span of 8 weeks, we had to make a game in c++, alongside starting to learn c++ from scratch at the same time.

What surprised me was - I did a lot of research making the game and every week we got introduced a new topic in university, I had already implemented the same concepts in the game. Starting from pointers and references to classes, structures and how to put those in a set.

I took the role as the project leader and led a group of 5 people. We took inspiration from Pokémon games, but funny enough - non of us had ever played an actual Pokémon game, we just had a brief idea of how the mechanics worked.

Non the less, I did have an awesome team:

First one was responsible for Login/Register system;
Second one made an SQL database;
Third one made graphics and sounds to bring the game to life;
Fourth one implemented a shop system;
While I made classes for every object, a fight system, A* path finding algorithm, a map and a map creator.

After login you get presented with the info screen, which let's you select a Pokémon and so on... If you've gotten this far, that means you can read and I don't need to list all the buttons.

The next big step comes after "Start game". You get presented with a map dialog with a players character, a few enemies and obstacles such as trees. Since we wanted to implement some cool algorithms, we chose that the movement would work with a mouse double click on the screen, rather than just the arrow keys. It then uses A* path finding algorithm to find a route between your current location and the click, avoiding obstacles on the way.

Underneath the picture overlay, there are drawn boundaries to permit movement over obstacles. We toggle the picture with a Shift key and see the magic happening.

I made a drawing system which I talk about here. So you can choose a brush and draw by holding down the left mouse button or erase with the right mouse button. You then save the map locally by specifying a unique name and it's turned in to a .txt file that contains every coloured block and it's colour. Inefficient, but easy to understand.

This is a simple demonstration of how the A* algorithm works. It finds a good enough route fairly fast and that is exactly what we need in a game.

Check out more on A* implementation here.

In conclusion, this has been a fun experience learning a new language by making a game. As a gamer myself, I found it easy to learn while working on something you enjoy, as well as I perfected my skills using Visual Studio making much use of Peek function or Debug with breakpoints. Not to mention the things I learned being a Project Manager and what it means to keep track of the project's current status and assigning tasks, while also making documentation.

Download the game and try it out yourself or see the GitHub repository https://github.coventry.ac.uk/jansonsa/D1

A Star (A*) Path Finding C++

Andris Jansons — Thu, 22 Mar 2018 00:36:50 +0000

A* (A star) path finding algorithm is an extension of the famous Dijkstra's path finding algorithm, which is more efficient, but occasionally doesn't actually find the best route, but just a good enough route.

The A* algorithm implementation

Let's take in account that our map is 1000x500 pixels divided in 50x25 blocks. I am using Magic Numbers to make it as widely usable as possible.



#define X_MAX 1000
#define X_STEP 20
#define Y_MAX 500
#define Y_STEP 20

Then I make a new structure to represent each Node (square) on the map. Since later on I am putting this structure in to a set, I first need to overload the operator < to tell the set which value we compare, since it is an ordered sequence.



struct Node
{
    int y;
    int x;
    int parentX;
    int parentY;
    float gCost;
    float hCost; 
    float fCost;
};

inline bool operator < (const Node& lhs, const Node& rhs)
{//We need to overload "<" to put our struct into a set
    return lhs.fCost < rhs.fCost;
}

Then we make Our Class and inside we use these functions:

First we need a Boolean to check whether a node(square) is valid - not an obstacle and not out of bounds.



    static bool isValid(int x, int y) { //If our Node is an obstacle it is not valid
        int id = x + y * (X_MAX / X_STEP);
        if (world.obstacles.count(id) == 0) {
            if (x < 0 || y < 0 || x >= (X_MAX / X_STEP) || y >= (Y_MAX / Y_STEP)) {
                return false;
            }
            return true;
        } 
        return false;
    }

We also need a Boolean to check if a node is our destination.



    static bool isDestination(int x, int y, Node dest) {
        if (x == dest.x && y == dest.y) {
            return true;
        }
        return false;
    }

This is where it starts to differ from Dijkstra's. We use H cost and F cost so we first check nodes that move towards our destination and only then the ones that move away from it.



    static double calculateH(int x, int y, Node dest) {
        double H = (sqrt((x - dest.x)*(x - dest.x)
            + (y - dest.y)*(y - dest.y)));
        return H;
    }

Now the algorithm itself



    static vector<Node> aStar(Node player, Node dest) {
        vector<Node> empty;
        if (isValid(dest.x, dest.y) == false) {
            cout << "Destination is an obstacle" << endl;
            return empty;
            //Destination is invalid
        }
        if (isDestination(player.x, player.y, dest)) {
            cout << "You are the destination" << endl;
            return empty;
            //You clicked on yourself
        }
        bool closedList[(X_MAX / X_STEP)][(Y_MAX / Y_STEP)];

        //Initialize whole map
        //Node allMap[50][25];
        array<array < Node, (Y_MAX / Y_STEP)>, (X_MAX / X_STEP)> allMap;
        for (int x = 0; x < (X_MAX / X_STEP); x++) {
            for (int y = 0; y < (Y_MAX / Y_STEP); y++) {
                allMap[x][y].fCost = FLT_MAX;
                allMap[x][y].gCost = FLT_MAX;
                allMap[x][y].hCost = FLT_MAX;
                allMap[x][y].parentX = -1;
                allMap[x][y].parentY = -1;
                allMap[x][y].x = x;
                allMap[x][y].y = y;

                closedList[x][y] = false;
            }
        }

        //Initialize our starting list
        int x = player.x;
        int y = player.y;
        allMap[x][y].fCost = 0.0;
        allMap[x][y].gCost = 0.0;
        allMap[x][y].hCost = 0.0;
        allMap[x][y].parentX = x;
        allMap[x][y].parentY = y;

        vector<Node> openList;  
        openList.emplace_back(allMap[x][y]);
        bool destinationFound = false;

        while (!openList.empty()&&openList.size()<(X_MAX / X_STEP)*(Y_MAX / Y_STEP)) {
            Node node;
            do {
                //This do-while loop could be replaced with extracting the first
                //element from a set, but you'd have to make the openList a set.
                //To be completely honest, I don't remember the reason why I do
                //it with a vector, but for now it's still an option, although
                //not as good as a set performance wise.
                float temp = FLT_MAX;
                vector<Node>::iterator itNode;
                for (vector<Node>::iterator it = openList.begin();
                    it != openList.end(); it = next(it)) {
                    Node n = *it;
                    if (n.fCost < temp) {
                        temp = n.fCost;
                        itNode = it;
                    }
                }
                node = *itNode;
                openList.erase(itNode);
            } while (isValid(node.x, node.y) == false);

            x = node.x;
            y = node.y;
            closedList[x][y] = true;

            //For each neighbour starting from North-West to South-East
            for (int newX = -1; newX <= 1; newX++) {
                for (int newY = -1; newY <= 1; newY++) {
                    double gNew, hNew, fNew;
                    if (isValid(x + newX, y + newY)) {
                        if (isDestination(x + newX, y + newY, dest))
                        {
                            //Destination found - make path
                            allMap[x + newX][y + newY].parentX = x;
                            allMap[x + newX][y + newY].parentY = y;
                            destinationFound = true;
                            return makePath(allMap, dest);
                        }
                        else if (closedList[x + newX][y + newY] == false)
                        {
                            gNew = node.gCost + 1.0;
                            hNew = calculateH(x + newX, y + newY, dest);
                            fNew = gNew + hNew;
                            // Check if this path is better than the one already present
                            if (allMap[x + newX][y + newY].fCost == FLT_MAX ||
                                allMap[x + newX][y + newY].fCost > fNew)
                            {
                                // Update the details of this neighbour node
                                allMap[x + newX][y + newY].fCost = fNew;
                                allMap[x + newX][y + newY].gCost = gNew;
                                allMap[x + newX][y + newY].hCost = hNew;
                                allMap[x + newX][y + newY].parentX = x;
                                allMap[x + newX][y + newY].parentY = y;
                                openList.emplace_back(allMap[x + newX][y + newY]);
                            }
                        }
                    }
                }
            }
            }
            if (destinationFound == false) {
                cout << "Destination not found" << endl;
                return empty;
        }
    }

You might notice that we're still missing one function makePath. That is where we follow each parent starting from our destination node till we reach our starting point while putting them inside a vector, we're later going to pass to aStar and from there to anyplace else we might find it useful.



    static vector<Node> makePath(array<array<Node, (Y_MAX / Y_STEP)>, (X_MAX / X_STEP)> map, Node dest) {
        try {
            cout << "Found a path" << endl;
            int x = dest.x;
            int y = dest.y;
            stack<Node> path;
            vector<Node> usablePath;

            while (!(map[x][y].parentX == x && map[x][y].parentY == y)
                && map[x][y].x != -1 && map[x][y].y != -1) 
            {
                path.push(map[x][y]);
                int tempX = map[x][y].parentX;
                int tempY = map[x][y].parentY;
                x = tempX;
                y = tempY;

            }
            path.push(map[x][y]);

            while (!path.empty()) {
                Node top = path.top();
                path.pop();
                usablePath.emplace_back(top);
            }
            return usablePath;
        }
        catch(const exception& e){
            cout << e.what() << endl;
        }
    }

To actually use the algorithm:

First we create a node for starting position as well as one for the destination and then run the algorithm.



            Node player;
            player.x = X / X_STEP;
            player.y = Y / Y_STEP;

            Node destination;
            destination.x = e->X / X_STEP;
            destination.y = e->Y / Y_STEP;

            for (Node node : YourClass::aStar(player, destination)) {
                //Your code here

            }

Check out my pokemon game where I use this algorithm here.
And check out just the code here.

Windows Forms Paint effect (C++)

Andris Jansons — Fri, 16 Feb 2018 20:50:35 +0000

Simulating a looping function while mouse is pressed

Microsoft paint kind of style:

What this function does is - it makes your function run every 10ms for example while working with Windows forms. Since such an event does not directly exist within the Windows Forms, we can achieve the same result using a few different ones together.

There are 2 scenarios:

Either draw on the grid clicking one pixel at a time with the regular MouseEventHandler(this, &project::panel1_MouseClick);(I know it does not seem as bad on such huge pixels);
Or, click and drag for as long as you wish to achieve continuous line (Let me show you how).

For this we are going to need 3 events, although the last one is optional:


this->panel1->MouseDown += gcnew System::Windows::Forms::MouseEventHandler(this, &frmAdventrureMap::panel1_MouseDown);
this->panel1->MouseUp += gcnew System::Windows::Forms::MouseEventHandler(this, &frmAdventrureMap::panel1_MouseUp);
this->panel1->MouseMove += gcnew System::Windows::Forms::MouseEventHandler(this, &frmAdventrureMap::panel1_MouseMove);

And a timer:

private: System::Windows::Forms::Timer^  timerMouseDrag;
this->timerMouseDrag = (gcnew System::Windows::Forms::Timer(this->components));
//Let's add a tick event
this->timerMouseDrag->Tick += gcnew System::EventHandler(this, &frmAdventrureMap::timerMouseDrag_Tick);
//And specify the interval
this->timerMouseDrag->Interval = 10;

To anyone just using Visual Studio Design View, this can not become any easier:

Now to the fun part

Some of you may already see where I am going with this, because what's left is just 2 lines of code:

private: System::Void panel1_MouseDown(System::Object^  sender, System::Windows::Forms::MouseEventArgs^  e) 
{
//Mouse pressed - Start the timer
    timerMouseDrag->Start();
}

private: System::Void panel1_MouseUp(System::Object^  sender, System::Windows::Forms::MouseEventArgs^  e) 
{
//Mouse released - Stop the timer
    timerMouseDrag->Stop();
}

And finally:

private: System::Void timerMouseDrag_Tick(System::Object^  sender, System::EventArgs^  e) 
{
    //Your code here (This is where I make the drawing happen)
}

That is it! "Simplicity is the ultimate sophistication."(Leonardo da Vinci)

But let's take this a step further

Remember the mouse move event we initialized earlier?
We use that one to pass our mouse position to our timer event or any other function we might call.
Simply creating a private attribute of MouseEventArgs^ or just assigning mouse x and y position:

private:
    System::Windows::Forms::MouseEventArgs^ mouse;
    //or
    int x, y;

And updating them each time MouseMove happens:

private: System::Void panel1_MouseMove(System::Object^  sender, System::Windows::Forms::MouseEventArgs^  e) 
    {
    mouse = e;
    //Or
    x = e->X;
    y = e->Y;
    }

To anyone thinking the same could be done without the timer but inside the MouseMove event - You're totally right, but what you are missing is the simple option to choose your preferred interval, furthermore MouseMove happens all the time, while our timer is working only when mouse is pressed.

In the end of the day, each and every project has its own methods it works best with.

Hope this helped someone or raised some new ideas, and if so, feel free to comment below.

Chatbot project

Andris Jansons — Thu, 23 Nov 2017 22:14:00 +0000

Hey, it's Andris

I'll start off with a picture of how the chatbot looks like

It's made with python using simple functionality. It uses API's.
I used slimkrazy's python wrap around for Google Places API, together with pyowm from Open Weather Map and had some fun with Riot's API for League of Legends (I doubt anyone wouldn't recognise the game).

The chatbot was a first year, first semester project. 6 random guys were put together in a group with one task "Make a chatbot." Although at that point of time it seemed like no big deal and we had all these crazy ideas that it has to have a specific personality and should even have some anger issues. We were fantasising how it would buy us stuff from the internet and be a man's best friend.
Don't take the picture for granted. It can make some simple small talk as well I am just shoving off the functionality I specifically made myself.
Little did we know the coding process did not go as planned. More or less everyone knew their tasks, but in the end there was no way to put them all together. One's functions accepted lists as parameters and returned strings, other's had it vice versa and it was a complete mess. Then two of us started making the same functions and while the best one got to the top, the other guy had just wasted his time. Overall code integration had us jumping around in a complete joy.

At this part I'm going to talk a bit about debugging so feel free to skip to the next paragraph as this word never brings good emotions. Especially to first years. We knew a good practice was to surround our code with try-catch blocks so our program wouldn't randomly crash, but when finally something does not work as intended it's almost impossible to find which part of the code went wrong. It's just that we forgot to print out the error itself. And if something works on one computer, that does not mean it will work on another. Furthermore while the code only runs on 32bit python on my laptop, a colleague can only run the same one on 64bit python. Unit testing was a way to go here as you make a function for testing other functions once, but run it every single time you need something to happen. And I don't know about you, but my lecturers have specifically told me to stay away from global variables. Right now I just can't think of how much to thank them as there was this one problem we spent nights trying to figure it out while in the end a single global variable did the trick.

In the end the chatbot is nothing like it was in the beginning. Literally the only thing it inherits is it's name - Snoo.py Snek (pun intended). But even with all the obstacles along the way, I am happy where it has lead me now. With this project I have taught myself more things than I could ever imagine existed. One of them being how to work as a team and what management tricks to use next time. The other - that there is a whole world of API's out there that I'm craving on exploring further.

See you all in the field of action!

GitHub link of course:
https://github.coventry.ac.uk/jonesd37/GroupD3
It's a uni's personal GitHub, so you can't find the repository on the regular GitHub.
To run it - launch "server1.py" and then "GUI.py" and there you go

Hi, I'm Andris Jansons

Andris Jansons — Thu, 23 Nov 2017 20:07:55 +0000

Hi everyone!

My name is Andris and I'm on my way to becoming a software developer. As of 2017 I'm a studying Computer Science in Coventry University residing in Britain.
I can speak Latvian, English, Python, Java, C# and the list is going to expand even more.
I love travelling and making the impossible possible, so hold on, because I'm about to bring some new code to the table!
If you want to chat either code related or not - contact me and let's meet up for a drink (You can choose coffee or beer)

Also - don't forget to add me on LinkedIn:

Andris Jansons