In the two weeks sprint for the new OpenUEM release, I’ve been working on the Linux agent for OpenUEM as it was on the top of the roadmap and several users have suggested including it ASAP.

OpenUEM is going to have a Debian/Ubuntu agent hopefully next week, and one of the things I wanted to offer was remote assistance sharing the user’s desktop.

OpenUEM wants to use existing technologies and offer a way for orgs without the budget to acquire proprietary solutions so the first choice for remote desktop was VNC as I was already using it for Windows agents.

Soon I learned that things were not going to be easy as, in recent years, Linux distributions have been using display servers that use Wayland replacing the aging X11 display servers.

OpenUEM Linux agents installed on endpoints that still use X11 will have remote assistance based on X11VNC and VNC, and those that use Wayland and Gnome will use Gnome Remote Desktop with… RDP.

Wait, is not RDP a protocol often related to Microsoft? Well, yes, it is.

The reason behind using Gnome Remote Desktop is that with Wayland few choices are out there that could offer VNC. Gnome Remote Desktop indeed offers VNC support for your Linux systems, but then I found that for Debian and Ubuntu, the VNC support was not included with the packages. So, to avoid future problems for other Linux agents (OpenSUSE, Arch, Fedora…) I finally decided to change VNC for RDP. Following this decision, KRDP will be tested for KDE Plasma desktops.

That’s why you’ll have to used RDP clients like Remmina, XFreeRDP or Windows Remote Desktop to open RDP files that will be generated by OpenUEM which will be also responsible for configuring the RDP service with digital certificates and starting the service for you automatically.

Please visit OpenUEM’s project site to know more about this free, open-source and self-hosted solution for your org to manage your endpoints.

OpenUEM has features that could categorize it as:

• An IT assets inventory
• A unified endpoint management tool (UEM)
• A remote monitoring and management tool (RMM)
• A mobile device management tool (MDM)

There are many tools out there that do those things, private or open source, so why another tool?

Well, why another car model, why another IA, why another programming language? Because there are different points of view and ways to approach a similar need.

OpenUEM tries to offer a new way to answer the question that we, as sysadmins, face every day: how can I do my job easier?

I have been a sysadmin for several years and the networks I’ve managed can be considered small to medium-sized. The organizations that I worked with either had no budget, so you were on your own, or were forced to buy expensive tools that were underused and too big for real needs.

OpenUEM is an open-source project that you can use for free. OpenUEM is based on open-source or free tools and protocols that are battle-tested or backed up by companies. You can use VNC for remote assistance, SFTP to transfer files, Windows information is gathered thanks to WMI, Windows apps and settings are managed using Winget, Linux apps are installed using Flatpak… All managed by OpenUEM web console and its agents (Linux agents are coming soon!).

If you are the IT administrator of a small company, you may not have spare equipment to install a management tool. If in the future your network grows, you may be concerned about how to migrate the functionality.

OpenUEM can be installed in a humble desktop machine with Windows 10 Home, Debian/Ubuntu Linux or any Docker powered environment. If you run a medium-sized or large company, you can use beefier machines and share the load as OpenUEM has been designed to have distributed components.

Many tools offer a lot of information and features about your endpoints, either you’re overwhelmed with the information provided, that you may not need, or the interface is too complex and needs a course from the company that created the software.

OpenUEM has a simple UI with concise information about your endpoints and what you can do with them. Docs are ready if you need a little help, and you can visit our Discord’s channel.

So, go ahead and try OpenUEM, help me to shape the project and to improve this project so it can help you to administer your network easily and effortlessly.

Ok, I feel a little bad about self-promotion but, as GitHub suggests me, I’ve invested some time to create a new open-source project, and I’d like to get feedback about the project and how to improve it, so I think that the best way is to show it here.

I’ve created OpenUEM, yet another inventory tool, to keep track of my IT assets using agents installed on my endpoints (for now Windows and Debian based distributions) and have some features that are important to me like remote file browsing, getting Windows Update and Antivirus status, deploying software via WinGet and Flatpak, remote assistance with VNC from the browser or RDP from remote desktop clients… using existing tools, protocols and libraries to avoid re-inventing the wheel. OpenUEM could be classified as a Remote Monitoring and Managing tool (RMM) or as a Unified Endpoint Management (UEM) tool.

In the past I used OCS Inventory, a nice open-source tool but I wanted something different with more features, that would make tasks easier, and I decided to create my own self-hosted solution with a clean interface (thanks to FrankenUI and HTMX) and a backend created with Go.

OpenUEM can be installed using Docker, Windows installers and Debian/Ubuntu packages hosted in my repository. The only requirement is to have a Postgres database and a DNS service in your LAN.

I’m preparing more features (automated tasks, remote code execution, RBAC…), but I’d like to create a roadmap with those that admins, using other tools, would like to see in OpenUEM if the project is interesting for them.

I’d love to see your comments and suggestions either here or in the project’s discussions section, and of course if you test it, please any bug report or issue with its installation would be appreciated (a lot).

Like any other new project, the hard part is getting users to feel interested, visit the project and decide to have a try, so enough of this shameful self-promotion, thanks for reading!

1) Create a bridge network in Docker. In my example I use drone as my network name:

`docker network create -d bridge drone`

2) Connect a running container, the one that you want to be connected from Drone containers, to your new network. In this example, my container is named as our_container_name.

`docker network connect drone our_container_name`

3) Launch your Drone Agent runner using the following env variable (Reference: https://docs.drone.io/runner/docker/configuration/reference/drone-runner-networks/):

`DRONE_RUNNER_NETWORKS=drone`

4) Whenever we want our Drone container to get access to a running container use your container name in your url, for example http://our_container_name. Using names, Docker will perform name resolution and thanks to your shared network Drone containers and your Docker containers will be connected.

In my tests, I tried to use the default Docker bridge named bridge, but it didn’t worked and in any case you may not want to use the default network to avoid external access, so that’s why I chose to create a new bridge network.

This discussion may help you: https://discourse.drone.io/t/drone-docker-agents-on-custom-network/3732

Hope it helps

This post assumes you have a Movies table in your local DynamoDB instance and you have loaded the sample data from a JSON file.

In my suggested code I’m heavily using the marshal operations that AWS gives me to prepare expressions. In Go we could define an expression like this:

ExpressionAttributeValues: map[string]*dynamodb.AttributeValue{
 “:r”: {
   N: aws.String(“0.5”),
 },
},

but I prefer to use the marshal operations, for example MarshalMap, to create the map[string]*dynamodb.AttributeValue, as I think the code is clearer and it’s easier to use the AttributeValues. You have plenty of alternative examples in Amazon AWS SDK for Go Examples page where the attribute values are defined as above if you prefer that way.

Step 3.1: Create a new item in our Movies table.

We’re going to add a new item representing a new movie:

{
   year: 2015,
   title: “The Big New Movie”,
   info: { 
     plot: “Nothing happens at all.”,
     rating: 0
   }
}

This is the flow of actions:

• We define a struct for the info and another struct for our movie.
• We create a session for our DynamoDB local server and start a connection.
• We use the utilities that AWS offers to marshal our movie, in this case we use the MarshalMap operation that takes our movie struct and prepares a map of attributevalues that we can use in the PutItem operation.
• We prepare the input for the PutItem operation selecting the Movies table and adding the movie that was marshalled before as the item to be inserted.
• We finally insert the new movie item.

Here’s the code for our main.go:

I run it

go run main.go

If the item is inserted we’ll see the following message

We have inserted a new item!

Step 3.2: Read an item

Now we’re going to read the item that we’ve just inserted. When we created the table we define two keys.

• Year is our partition key.
• Title is our sort key.

You may review the AWS DynamoDB core concepts article if you don’t remember what is a partition key and a sort key.

We’re going to use both keys to get the item from our table as it was a composite primary key.

Here’s the flow:

• We define a struct for the movie to be retrieved. The type for the info field has been defined as interface{}, that way I can expect arbitrary data for the movie info. Also I define the info field to be omitted in the JSON object if it’s empty.
• We create a session for our DynamoDB local server and start a connection.
• We prepare a key struct to be marshalled using MarshalMap. The marshalled key is added to key field inside a GetItemInput struct.
• We retrieve the item using the input.
• We get a GetItemOutput that contains an Item field. We unmarshall the item using UmarshallMap and store the content in a Movie struct.
• Note: the info field may contain arbitrary data so I can use the method described in the JSON and Go Blog post to retrieve data. If we know what is going to be inside the info field we could define a struct for the info and we could avoid that logic. I feel it was right for this tutorial assuming that we don’t know what’s inside the info field.

Here’s the code for our main.go

I run it again

go run main.go

And here’s the result

year: 2015
title: The Big New Movie
rating : 0
plot : Nothing happens at all.

Step 3.3: Update an Item

In this step we want to update the previous Item with the following information:

{
   year: 2015,
   title: “The Big New Movie”,
   info: { 
      plot: “Everything happens all at once.”,
      rating: 5.5,
      actors: [“Larry”, “Moe”, “Curly”]
   }
}

Here’s the flow:

• We define a struct for the key of the movie item to be updated.
• We define a struct that contains which fields are going to be updated. The struct contains json mappings with a name started with a colon, in AWS we use those tokens as placeholders for the info to be updated. For example rating will use :r and plot will use :p. You have more information in the API reference.
• We also create two structs to be used when we unmarshal the data returned by the update operation.
• We create a session for our DynamoDB local server and start a connection.
• We prepare a key struct to be marshalled using MarshalMap. The marshalled key is added to key field inside an UpdateItemInput struct and is used to select which item must be updated.
• We prepare a movieUpdate struct to be marshalled using MarshalMap. The marshalled update info will be added to an UpdateItemInput struct.
• The UpdateItem operation requires the key for the item to be updated and the updated info. Also the UpdateExpression specifies what’s the mapping between the info fields and the tokens prefixed by a colon, similar to a SET clause in SQL. The ReturnValues set to UPDATED_NEW instructs DynamoDB to return only the values that have been updated.
• The UpdateItem operation returns an UpdatedItemOutput which contains an Attributes field with the updated information. We use the UnmarshallMap operation using a MovieInfoUpdated struct to store the unmarshalled fields. Then we can print the new values.

Here’s the code for our main.go

And here’s the output for the updated info.

Updated plot: Everything happens all at once.
Updated rating: 5.5
Updated actors: [Larry Moe Curly]

Step 3.4: Increment an Atomic Counter

According to the Node.js tutorial, we are going to increment the rating for a movie using a counter.

Here’s the flow:

• We define a struct for the key of the movie item to be updated.
• We define a struct that contains the increment for the movie reating field. The struct contains a json mapping with a name started with a colon :val, in AWS we use those tokens as placeholders.
• We also create two structs to be used when we unmarshal the data returned by the update operation.
• We create a session for our DynamoDB local server and start a connection.
• We prepare a key struct to be marshalled using MarshalMap. The marshalled key is added to key field inside an UpdateItemInput struct and is used to select which item must be updated.
• We prepare a MovieRatingInc struct to be marshalled using MarshalMap with the number to be used in the increment operation.
• The UpdateItem operation requires the key for the item to be updated and the updated info. Also the UpdateExpression specifies that rating is going to be incremented by the value we’ve set earlier.
• The UpdateItem operation returns an UpdatedItemOutput which contains an Attributes field with the updated information. We use the UnmarshallMap operation using a MovieInfoUpdated struct to store the unmarshalled fields. Then we can print the new values.

Here’s the code for our main.go

And here’s the output for the updated info, ratings have been increased by 1.

Updated rating: 6.5

Step 3.5: Update an Item (Conditionally)

We’re going to update an item from our Movies table. If a movie has more than three actors we will remove the first actor, so we’re going to select a condition as we would use a WHERE clause in SQL.

Here’s the flow:

• We define a struct for the key of the movie item to be updated.
• We define a struct that contains which is the number of actors to be checked in the condition. The struct contains a json mapping with a name started with a colon :num, in AWS we use those tokens as placeholders.
• We also create two structs to be used when we unmarshal the data returned by the update operation.
• We create a session for our DynamoDB local server and start a connection.
• We prepare a key struct to be marshalled using MarshalMap. The marshalled key is added to key field inside an UpdateItemInput struct and is used to select which item must be updated.
• We prepare a MovieActorsCondition struct to be marshalled using MarshalMap with the number to be used when the number of actors in a movie is checked.
• The UpdateItem operation requires the key for the item to be updated and the updated info. The UpdateExpression defines that we want to remove the first item in the actorrs array. The ConditionExpression specifies that the item will be updated only if the number of actors (size) is greater than 3.
• The UpdateItem operation returns an UpdatedItemOutput which contains an Attributes field with the updated information. We use the UnmarshallMap operation using a MovieInfoUpdated struct to store the unmarshalled fields. Then we can print the new value.

Here’s the code:

When we run the code we’ll check that the condition fails as we have only three actors:

ConditionalCheckFailedException: The conditional request failed
 status code: 400, request id: 3d6f2674–7de9–4a8c-ae6e-dfb98b49b691

We modify the main.go and change the condition, this time we’ll check size(info.actors) >= 3

Now when we run the code, we get the updated actors array where the first actor has been removed:

Actors updated: [Moe Curly]

Step 3.6: Delete an Item

In this final step we’re going to delete an Item if a condition is met. We’re going to delete an Item if the movie’s rating is lower than 5

Here’s the flow:

• We define a struct for the key of the movie item to be updated.
• We define a struct that contains which is the rating to be checked in the condition. The struct contains a json mapping with a name started with a colon :val, in AWS we use those tokens as placeholders.
• We also create two structs to be used when we unmarshal the data returned by the update operation.
• We create a session for our DynamoDB local server and start a connection.
• We prepare a key struct to be marshalled using MarshalMap. The marshalled key is added to key field inside a DeletetemInput struct and is used to select which item must be removed.
• We prepare a MovieRatingCondition struct to be marshalled using MarshalMap with the rating to be used in the condition.
• The DeleteItem operation requires the key for the item to be deleted. The ConditionExpression specifies that the item will be removed only if the rating is lower than or equal to 5.0.

Here’s the code:

When we run the code our movie has a rating of 6.5 so it’s not deleted:

ConditionalCheckFailedException: The conditional request failed
 status code: 400, request id: 07d86ea1–5d42–4016–9b7e-47a4b1fa0f82

If we change the condition so the movie is deleted if the rating is lower than 10, now the item will be deleted.

The item has been deleted

This concludes the third part of the tutorial. In the next part we’re going to query and scan the data.

We’ll start downloading the sample file provided by Amazon AWS to the directory where our main.go file lives. In the following line I download the zip file using wget, unzip it and remove the file in my Linux machine:

wget -O moviedata.zip https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/samples/moviedata.zip; unzip moviedata.zip; rm moviedata.zip

We’ll now have a moviedata.json file where Amazon AWS is giving us some movies that can be added to our table. This is the JSON structure for one of the movies where year is the partition key and title is used as a sort key, the rest of the information is stored in the info attribute.

{
 “year”: 2013,
 “title”: “Rush”,
 “info”: {
   “directors”: [“Ron Howard”],
   “release_date”: “2013–09–02T00:00:00Z”,
   “rating”: 8.3,
   “genres”: [
     “Action”,
     “Biography”,
     “Drama”,
     “Sport”
   ],
   “image_url”: “http://ia.media-imdb.com/images/M/MV5BMTQyMDE0MTY0OV5BMl5BanBnXkFtZTcwMjI2OTI0OQ@@._V1_SX400_.jpg",
   “plot”: “A re-creation of the merciless 1970s rivalry between Formula One rivals James Hunt and Niki Lauda.”,
   “rank”: 2,
   “running_time_secs”: 7380,
   “actors”: [
     “Daniel Bruhl”,
     “Chris Hemsworth”,
     “Olivia Wilde”
   ]
 }
}

In our main.go file I assume that you’ve created a table in your local DynamoDB as explained in the first part of the tutorial. Now we’ll use Go to read the json file and add the sample data to our Movies table. This is the flow:

• Define a structure that will be used to parse the JSON objects inside the moviedata.json file. The JSON objects have a year which is an integer, a title which is a string and info which is an object. As the info object can have arbitrary attributes as the type for info as explained in the JSON and Go blog post.
• Open the JSON file.
• Use the JSON decoder to unmarshal the contents of the moviedata.json file.
• Create a session and a DynamoDB service connection as explained in the first part of this tutorial.
• Loop throught the movies objects parsed from the JSON file.
• For each movie we can use the MarshalMap function from the dynamodbattribute library which helps us to create the map of AttributeValues that Amazon AWS expect as the item to be inserted in the table using the PutItem operation.
• Create a PutItem input with the map of AttributeValues which represents the movie and its attributes like year, title and info. Also we specify the name of the table.
• Finally put the item using the input we’ve just created. This operation will create the item in the table. In DynamoDB’s terminology is a group of attributes that is uniquely identifiable among all of the other items.

This would be the source code for the main.go file that would populate our table with the sample data.

Now before running our main.go, please run the go get command to download all the required packages.

go get

And finally go run your main.go

go run main.go

If the import operation is successful we’ll see a message with the number of records imported:

We have processed 4609 records

In the next part of this tutorial we’ll see how we can perform CRUD operations now that our table has some sample data.

In order to help you discover how you can use Go with DynamoDB I’m rewriting the Node.js tutorial for Go.

The first prerequisite is downloading and running DynamoDB locally in your computer as explained by Amazon AWS. It’s great that Amazon AWS gives you the chance to run DynamoDB in your local machine so you can learn how to use it for free.

I’ve started my DynamoDB using the following java command. DynamoDB will use port 8000 by default but you can use a different port if you want.

java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -sharedDb
Initializing DynamoDB Local with the following configuration:
Port: 8000
InMemory: false
DbPath: null
SharedDb: true
shouldDelayTransientStatuses: false
CorsParams: *

If you’re starting with Go please review the How to Write Code article about where you should store your source code. In this post I’m creating my main.go file inside my $GOPATH/src/github.com/doncicuto/dynamodb_tutorial path.

Also if it’s the first time you use DynamoDB you may start reading the following AWS article about the core components of DynamoDB.

Step 1. Create a Table

Once we have our DynamoDB instance working locally you can copy and paste the following program into the main.go. The code has the following flow:

• An Amazon configuration struct is created assigning the local endpoint which points to the default port 8000. Region is required but not used in this local example so you can use any of the available regions, for example us-west-2.
• A new Amazon AWS session is created.
• We create a connection to DynamoDB service using the session we’ve just created.
• Then we create the DynamoDB table definition where two attributes are used for describing a movie: a year and a title. Year will be our partition key and title will be our sort key. We also specify our initial read and write throughput settings. Please read the following Amazon AWS article for more information about DynamoDB Tables management.
• Finally we create the table using our table definition.

Now before running our main.go, please run the go get command to download the official Amazon AWS go sdk (Note that Amazon is preparing a AWS SDK for Go 2.0).

go get

And finally go run your main.go

go run main.go

If the operation was successful you’ll see the result of creating the table in your local DynamoDB server.

{
 TableDescription: {
 AttributeDefinitions: [{
 AttributeName: “Year”,
 AttributeType: “N”
 },{
 AttributeName: “Title”,
 AttributeType: “S”
 }],
 CreationDateTime: 2018–01–22 07:21:17 +0000 UTC,
 ItemCount: 0,
 KeySchema: [{
 AttributeName: “Year”,
 KeyType: “HASH”
 },{
 AttributeName: “Title”,
 KeyType: “RANGE”
 }],
 ProvisionedThroughput: {
 LastDecreaseDateTime: 1970–01–01 00:00:00 +0000 UTC,
 LastIncreaseDateTime: 1970–01–01 00:00:00 +0000 UTC,
 NumberOfDecreasesToday: 0,
 ReadCapacityUnits: 1,
 WriteCapacityUnits: 1
 },
 TableArn: “arn:aws:dynamodb:ddblocal:000000000000:table/Movies”,
 TableName: “MoviesTest”,
 TableSizeBytes: 0,
 TableStatus: “ACTIVE”
 }
}

In the next part of the tutorial we’ll populate the Movies table.