Forem: José Coelho

5 DevOps tools to boost your open source project

José Coelho — Thu, 19 Mar 2020 00:10:05 +0000

Nowadays if you want your open source project to thrive, attract contributors and get traction among the community, there's no doubt, you need to have basic CI/CD - or any other continuous - processes implemented.

Any open source contributions that you put out there should be backed by processes to make sure they are valid and working.

Whether it's a web application, a new Docker image, a mobile app, an Ansible role, etc., you should always have your work double-checked, and there are tons of free and easy to use tools to help you.

Here are 5 tools that I use and recommend for your next contributions.

Circle CI

Let's start with the basic and the base of a stable and trustworthy codebase - implementing a CI pipeline.

Circle CI is a cloud-native CI/CD tool, that lets you quickly set up a CI pipeline for your projects.

Just register your project on Circle CI and add a config.yml inside the .circleci folder on the root of your project repository and you're done.

For example, a simple Gradle project can be set up with the following config.yml:

version: 2
jobs:
    build:
        docker:
            - image: circleci/openjdk:8-jdk
        steps:
            - checkout
            - run: mvn compile

There are a lot of other similar tools, I usually use CircleCI but any other tool should do the job.

Codacy

As your project starts to get traction, and more and more contributions, you should have a gatekeeper on every pull request to make sure the quality of your code does not go down.

Codacy is a great tool for that, it scans your code and detects code smells, technical debt, bugs and helps you maintain a healthy codebase in general.

It's very easy to integrate into your current workflow and gives you great insights into your code with graphs pinpointing the most problematic areas of your code.

Snyk

Any project is vulnerable to security issues, especially if it's using third-party libraries. Snyk is your best friend in this situation, it will scan your project dependencies and report any known vulnerabilities.

It can open automatically a PR on your repository with the compromised dependencies update, you'll just have to review it and migrate your code to the dependency's new version.

If your project is containerized, Snyk can even alert you for vulnerabilities on your container images.

Snyk displays the vulnerabilities by severity and you can generate reports and lists of known issues in your project.

Netlify

If you're building a modern frontend static application, Netlify is a great way to quickly set up a continuous deployment flow.

It connects directly to your git repository and listens for changes on your default branch. It will then build and deploy your frontend application.

Besides providing a great free plan Netlify also has some very useful features like the 1-Click HTTPS and the deploy preview which builds and deploys every open pull request on a different URL. This way you can quickly see your changes live before merging your PR.

Semantic versioning and Changelog

If you want your open source project to be taken seriously you should keep a changelog and start thinking about versioning your project right from the beginning.

Versioning and changelogs are important once your project starts to get traction. It will boost developers' confidence in your project since changes are tracked and they won't be blindsided by breaking changes - if you follow semantic versioning correctly.

If you're unfamiliar with Semantic versioning you can read the specs and Keep a changelog is a great place to start with changelogs.

What do you think about these tools? Would you add any other tools to the list?

Personal website template - an open source project

José Coelho — Tue, 31 Dec 2019 23:21:19 +0000

The idea

A few months ago I started looking for a new job and one of the first steps I took was to build my personal webpage with my CV information.

How I did it?

I'm mostly a backend developer so I wanted to explore one of the popular JS frameworks, as I don't have that opportunity at work.

So I decided to go with ReactJS and the CSS framework Bulma for styling.

And here it is the final result: https://jcoelho93.netlify.com

Dev.to latest articles

This app uses the Dev.to REST API to display my latest published articles, so this is a perfect template for anyone who's part of this community ;)

JSON Resume open source initiative standard

One of the requirements I had in mind was that the application should load all the personal information from a json file so that I could easily update the website with my most recent information.

So I found this open-source initiative called JSON Resume, that sets a standard for representing resumes as json. So my app expects the json file to follow this standard.

Make it your own

Recently someone forked my project on GitHub, updated the json file with their personal information and made their own personal webpage.
This made think about promoting my project to anyone who wishes to use it as a base for their own website and make it truly open source community driven.

So here is my project

jcoelho93 / personal-website

My personal website

jcoelho93 Personal website

This is my personal website built using ReactJS and Bulma as the CSS framework. Live here

The personal information on the website is populated from a json file that follows the JSON Resume open source standard.

Use Node v16.15.1

Customizing it

Feel free to fork this project and update it with your own information and style. Just update the ´src/resume.json´ with your personal information.

If you improve the app in any way a PR would be very apreciated ;)

Build

Clone the repo:

> git clone https://github.com/jcoelho93/personal-website.git

Update the resume.json with your personal information (check JSON Resume)
Install dependencies and run build command:

> npm install
> npm run build

You can also test the app with a development server, just run:

> npm start

Contributing

Feel free to fork this project and customize with your personal info. If you implement any nice features or improvements…

View on GitHub

What do you think of the project? And the webpage itself?

If you want you can fork it and make it your own, then send me the link I'd love to have a look at what you did.

Also if you make any improvements on the app a PR would be very appreciated. :)

PowerShell Universal Dashboard: Making interactive dashboards

José Coelho — Tue, 11 Jun 2019 08:18:53 +0000

PowerShell Universal Dashboard

PowerShell Universal Dashboard is a very cool PowerShell module and one of the most interesting open source projects I have come across.
It allows you to create web-based, beautiful and interactive dashboards for your IT systems, using solely PowerShell commands.
It works great for setting up monitoring dashboards to keep track of your systems.

It's every sysadmin's dream to have a big screen in their office where they can see the status of their systems.

Let's build one

Let's get down to business and set up a simple dashboard so we can get to know the tool.
(To follow along you'll need PowerShell 5+ and to follow the instructions on how to install the module.)

Create a dashboard.ps1 file and add the following code:



$dashboard = New-UDDashboard -Title "DevTo Dashboard" -Content{
    New-UDHeading -Text "DevTo"
}

Start-UDDashboard -Dashboard $dashboard -Port 1000 -AutoReload

Here we are creating our dashboard object and adding a heading to it.
If everything is right once you execute this file you should get the following output:



Name       Port Running
----       ---- -------
Dashboard2 1000    True

And your dashboard should be available at http://localhost:1000 :

Now let's make it cooler and add a different theme, I particularly like the built-in Azure theme:



$theme = Get-UDTheme -Name 'Azure'
$dashboard = New-UDDashboard -Title "DevTo Dashboard" -Theme $theme -Content{
    New-UDHeading -Text "DevTo"
}
...

Way cooler now, right?

Monitoring

PowerShell Universal Dashboard has a component called monitor which is a particular type of chart that tracks data over time. You can use it, for example, to plot your CPU or memory usage.



$theme = Get-UDTheme -Name 'Azure'
$dashboard = New-UDDashboard -Title "DevTo Dashboard" -Theme $theme -Content{
New-UdMonitor -Title "CPU (% processor time)" -Type Line -DataPointHistory 20 -RefreshInterval 10 -ChartBackgroundColor '#80FF6B63' -ChartBorderColor '#FFFF6B63'  -Endpoint {
            try {
                Get-Counter '\Processor(_Total)\% Processor Time' -ErrorAction SilentlyContinue | Select-Object -ExpandProperty CounterSamples | Select-Object -ExpandProperty CookedValue | Out-UDMonitorData
            }
            catch {
                0 | Out-UDMonitorData
            }
        }
}

Start-UDDashboard -Dashboard $dashboard -Port 1000 -AutoReload

Basically what we are doing here is using the Get-Counter cmdlet to fetch real-time data from Windows performance monitoring tool, and then piping it through the Out-UDMonitorData which will convert this information into data readable by the Monitor.

Un*x users: This specific command will only work on Windows, so you would need to find a different strategy to get your CPU data.
Maybe try using the mpstat command from the sysstat package and then parsing the data with Powershell.

Charts

Another really useful component is charts. You can display all sorts of data into either a bar, line, doughnut or pie chart. They are very customizable and easy to use as they are built with the Chart.js library.

You can, for example, use a doughnut chart to show you used and available disk space:



$theme = Get-UDTheme -Name 'Azure'
$dashboard = New-UDDashboard -Title "DevTo Dashboard" -Theme $theme -Content{

New-UDChart -Title "Disk Space" -Type Doughnut -RefreshInterval $refreshRate -Endpoint {  
            try {
                Get-CimInstance -ClassName Win32_LogicalDisk | Where-Object {$_.DriveType -eq '3'} | Select-Object -First 1 -Property DeviceID,Size,FreeSpace | ForEach-Object {
                    @([PSCustomObject]@{
                        Label = "Used Space"
                        Data = [Math]::Round(($_.Size - $_.FreeSpace) / 1GB, 2);
                    },
                    [PSCustomObject]@{
                        Label = "Free Space"
                        Data = [Math]::Round($_.FreeSpace / 1GB, 2);
                    }) | Out-UDChartData -DataProperty "Data" -LabelProperty "Label" -BackgroundColor @("#80FF6B63","#8028E842") -HoverBackgroundColor @("#80FF6B63","#8028E842") -BorderColor @("#80FF6B63","#8028E842") -HoverBorderColor @("#F2675F","#68e87a")
                }
            }
            catch {
                0 | Out-UDChartData -DataProperty "Data" -LabelProperty "Label"
            }
        }

}

Start-UDDashboard -Dashboard $dashboard -Port 1000 -AutoReload

You can now join both the Monitor and the Chart on your dashboard. Here's how your dashboard should look by now. Pretty cool hun? 😃

Un*x users: Again this will only work for Windows, but you can easily workaround and adapt it for Un*x systems.

And there you have it! A pretty cool a good looking dashboard. Now get yourself a big screen on the wall and display it.

Explore

These examples are just a fraction of what this framework can do. You can also build simple REST API, have multiple pages rotate dynamically, have input forms to fill out and a lot of other components.

The best thing you can do is to check by yourself, they have pretty good documentation.

I hope you found this tool as interesting and useful as I did.

What do you think about this PowerShell module? If you have used this tool, let me know how in the comments :)

8 Jenkins plugins I can't live without

José Coelho — Mon, 28 Jan 2019 09:05:11 +0000

Jenkins is a great open source automation platform. It has some great features straight out of the box.

However, in my opinion, what makes it standout is its community and the plugins it develops.

There are more than a thousand plugins available to support almost every technology, tool and process for building, deploying and automating your projects.

These are some of the plugins I use the most and which without I would have my work a lot harder.

1. Ansi Color Plugin

Let's start with a simple one. Jenkins's console does not support ANSI escape sequences, specifically color ones, out of the box. This means that whatever tool you're using the console will be just black and white.

Ansi Color plugin adds support for ANSI escape sequences to the Jenkins console output, making it possible to have colored output on your logs. This depends on the tool your using, if it doesn't print ANSI characters there's nothing you can do.

2. Blue Ocean Plugin

Let's face it! Jenkins UI is not the greatest, however there are lots of plugins that adress this issue.

Blue Ocean gives you an incredibly user friendly UI to interact with Jenkins. Its developers claim that anyone, even non technical people, can use Jenkins easily with Blue Ocean.

Here's a pipeline representation in Blue Ocean:

Tip: Blue Ocean works great when you're trying to analyze logs of a pipeline running tasks in parallel. On the classic view, parallel logs are scrambled.

3. Git Parameter Plugin

When you spend most of your day building pipelines and automating boring tasks, you want people to actually use them. To achieve that you have to make it easy to use.

Git Parameter plugin lets you have Git branches, tags or revisions as a parameter for starting a job or pipeline.

This is really useful if, for example, you want to setup a continuous delivery pipeline where the developer can choose from which Git tag to deploy from.

Tip: always filter branches/tags according to the pipelines purposes, otherwise you might end up with instable code in production environments for example.

4. GitLab Plugin

In my company, we use a hosted GitLab instance as our source code management tool. And even though I love GitLab's approach to CI (have a read) we haven't gone that route.

So we use Jenkins instead and connect it to GitLab. In the end, developers have the same experience.

GitLab plugin lets you call pipelines from GitLab, using WebHooks, and publish the build results back to GitLab.

This allows you to quickly get feedback from your CI pipelines.

You can find the similar plugins for other SCM tools.

Tip: favor execution of pipelines through WebHooks over SCM polling when ever you can. On big systems you'll get better performance.

5. Extended Email Plugin

When something goes wrong you need your users to fix the problem as soon as possible, otherwise your CI/CD could be compromised.

Extended Email plugin extends Jenkins email notifications giving control over almost every aspect of it. You can customize the notifications triggers, content and recipients.

Have a look at these recipes to have some ideas of your own.

Tip: make sure every notification you send is absolutely necessary, do not spam your users. Trust me, the less notifications you send the more users will read them and actually react to them. Use IM plugins (like Slack plugin or Skype plugin) to sparse your notifications.

6. embedabble-build-status Plugin

Another great way to warn your users when something is wrong is to use Badges on your SCM tool.

This plugin generates badges for all your jobs which display, in real time, their build status.

7. Publish over SSH Plugin

As you probably take from the name, this plugin provides features to send files and run commands over SSH.

You can configure your remote hosts on you Manage Jenkins page and then use them on your jobs.

Tip: if for some reason you cannot have a Jenkins agent installed on one of yours hosts, this plugin allows you to run commands remotely over SSH.

8. Next Executions Plugin

Once you get a considerable amount of jobs set up, it might get hard to keep up with every thing that's happening and running on your Jenkins.

Next Executions Plugin adds a widget to the main page of your Jenkins instance that displays the next build date of all your scheduled jobs.

This will give you a much better picture of the state of your infrastructure.

Conclusion

These are some of the plugins I use every day and there are thousands more to explore.

Do you have any favorite one? Let me know in the comments! I'm looking for some new favorite plugins :D

10 reasons to use Groovy in 2019

José Coelho — Sat, 05 Jan 2019 16:47:13 +0000

Why Groovy?

It's been about a year since I joined my company's DevOps team and one of the main tools we use is Jenkins which gets along great with Groovy. I mostly use Groovy for orchestrating pipelines and automating some boring tasks.

Groovy is a powerful language for the Java platform, it integrates smoothly with any Java program. It's also a great scripting language with its powerful and easy to learn syntax.

[Groovy is] aimed at improving developer productivity thanks to a concise, familiar and easy to learn
syntax. It integrates smoothly with any Java program, and immediately delivers to your application
powerful features, including scripting capabilities, Domain-Specific Language authoring,
runtime and compile-time meta-programming and functional programming.

So here are 10 features that I've learned in the past year that made me love Groovy:

1. Simplicity

Coming from a Java back-end development team, learning Groovy was a breeze for me. It is build on top of Java standard libraries, providing extra features. Most of them make programming much simpler.

1.1 Declaring Lists/Maps

Groovy is an optionally typed language, you can use the def keyword to declare variables. For example declaring lists or maps is as simple as:

def myList = []
def myMap = [:]

1.2 Iterating over Lists/Maps

And iterating over them is incredibly easy and readable using Closures:

myList.each {element -> 
    println element
}

myMap.each {entry -> 
    println "User: $entry.user | Email: $entry.email"
}

2. String Interpolation

[String] Interpolation is the act of replacing a placeholder in the string with its value upon evaluation of the string.

In Groovy, placeholders are surrounded by ${}or prefixed with $ for dotted expressions.

In the previous snippet we can see an example of string interpolation. But here is another one:

try{
    throw new Exception()
}catch(Exception e){
    println "Error during operation. Cause: ${e}"
}

3. Casting

Groovy makes casting very easy and readable with the as operator. To use this operand the casted class must implement the asType()method. This already happens for standard classes like lists, enumerators, etc.

For example:

enum Employee {
    MIKE,
    HANNA
}

String name = "JOHN"

try{
    name as Employee
}catch(Exception e){
    println "Could not find employee ${name}. Cause: ${e}"
}

4. Json to Classes

I work a lot with Web Services with Json responses so inevitably I have had to map responses to Groovy classes. This comes out of the box with Groovy and it's extremely easy, just pass a Json through the class constructor.

String response = '{name:"John", position: "Developer", age: 32}'

// Json response to map
def employeeMap = new JsonSlurper().parseText(response)
// Consider an Employee class with the attributes name, position and age
Employee employee = new Employee(employeeMap)

That's it. We just built an employee object from a Json string.

The other way around is just as simple:

def json = JsonOutput.toJson(employee)
// json == '{name:"John", position: "Developer", age: 32}'

5. Assertions

Groovy has the same assert statement as Java, but way more powerful - hence it's name - Power Assertions.

The difference being its output in case the assertions resolves to false. For example:

def contacts = ['John', 'Anna']

assert contacts.isEmpty()

//Output:
//ERROR org.codehaus.groovy.runtime.powerassert.PowerAssetionError:
//assert contacts.isEmpty()
//       |        |
//       |        false
//       [John, Anna]

This allows you to very easily understand what has made the assertion fail.

6. Defining variables

Groovy is optionally type, this means that you can define a variable with its type or simply use the keyword def. This applies as well when declaring List or Maps, their types are optional. For example:

String name
int age
def address
List friends = ['John', 'Anna']
Map family = ['Mother':'Mary', 'Father':'Joseph']

def getFamilyMember("Mother"){ ... }

For those of you who know Javascript, this is similar to the keyword var.

This gives you incredible flexibility, however be cautious when using it. It might make it harder on your team or someone else using your code to read it and understand what is expected as input or output.

7. Hashing

If you've ever used Java, you probably know how verbose it is to hash a string - unless you're using a third-party library.

Groovy 2.5 brings us some useful methods to the String class. Calculating hashes is as simple as calling a method on a String. Groovy makes it simple:

def password = "thisIsMyPassword"

def md5 = password.md5()
def sha256 = password.sha256()
//For other algorithms use digest() method
def sha1 = password.digest('SHA-1')
...

8. Operators

Groovy supports the most common operators found in other languages. But that's not enough the are some more interesting operators Groovy provides. Here are a few:

Elvis operator

This is a shorter version of the ternary operator. This is very useful, for example, when the condition could evaluate to null.

// Instead of this
def user = person.name ? person.name : 'Guest'
// Use this
def user = person.name ?: 'Guest'

Safe navigation operator

Another operator that can be used to check if a variable is null is the Safe Navigation Operator.

def user = person?.name
// user == null

Use this operator when you want to avoid NullPointerExceptions. In case the object you're accessing is null, this operator will return a null instead of throwing a NullPointerException.

Spread Operator

The spread operator (.*) is used to execute an action on all items of a Collection, instead of using a loop or a closure as we've seen before. For example:

def numbers = [1,2,3,4,5,6]
*numbers // == [1,2,3,4,5,6]

def people = [
    new Person(name: 'John', age: '25'),
    new Person(name: 'Anna', age: '21')
]

def friends = people*.name // friends = ['John', 'Anna']

9. Traits

Traits are a structural construct of the language which allows:

composition of behaviors

runtime implementation of interfaces

behavior overriding

compatibility with static type checking/compilation

I like to think of traits as interfaces where you can actually implements methods. It's very useful when you have a very complex and structured application and you want to keep things clean.

It's definetly something I've missed in the early Java.

Here's an example:

trait Sociable {
    void greet() { println "Hello!" }
}

class Person implements Sociable {}

Person p = new Person()
p.greet() // Hello!

10. Regular Expressions

Groovy natively supports regular expressions and it's quite simple. It has 3 operators for regular expressions:

~ this is the pattern operator, its the simple way to create an instance of java.util.regex.Pattern:

def pattern = ~"^abc{2}\d"
// pattern instanceof Pattern == true

=~ this is the find operator which will look for a pattern in a string and returns a Matcher:

def pattern = ~"abc{2}\d"
def found = "abcc5" =~ pattern
// found instanceof Matcher == true

and finally the match operator ==~ which returns true if the string is a strict match of the regex:

def found = "abcc5" ==~ pattern
// found == true

Conclusion

Groovy feels like a breath of fresh air if you've been programming in Java, or other OOP languages, for years.

It makes things so much easier and simple and way less verbose. Plus the extra features like scripting and Domain Specific Language capabilities, push Groovy to a new level and gives it this new fresh look that's missing for older languages.

I hope you found this article interesting and let me know in the comments below if you have any experience with Groovy and how do you use it. :)

5+ Free development resources for Students

José Coelho — Mon, 12 Nov 2018 23:38:32 +0000

Free for students

If you're a University student you could have access to some really neat tools for free, for you to develop and explore the CS world.

Usually, to get these tools, you will need an official institutional email address. However you can also provide your student card or some other proof.

Here are a few!!!

1. JetBrains IDEs

In my opinion, these are some of the best IDEs in the market right now. They have incredible UI and features and they actually make me enjoy my school assignments a bit more.

Tools such as IntelliJ IDEA Ultimate for Java based applications, PhpStorm for PHP, PyCharm for Python and my personal favorite which I have recently started using and can't get enough CLion for C/C++.

They also have a really interesting plugin (still in beta) for their IDEs which will help you learn your chosen language with exercises from inside your IDE.

2. GitLab for education

GitLab is becoming a great tool for collaborating and developing on great projects. Their focus is currently on simplifying the DevOps lifecycle. This is a great way to start acquiring a DevOps mindset for your future once you get on the job market.

GitLab is the first single application for the entire DevOps lifecycle. Only GitLab enables Concurrent DevOps , unlocking organizations from the constraints of the toolchain.

GitLab for education allows your educational institution to use GitLab Ultimate and Gold for free.

Unfortunately only institutions may apply (students can't apply directly), however you can still have your projects hosted on GitLab with full functionality if you make them open source or with the free functionality for private projects.

3. GitHub Education

GitHub Education offers a great set of development tools for free for students. From text editors like Atom to Git graphic tools like GitKraken, to cloud services that provide CI, email services, hosting and a lot more.

All you need to apply is to fill in a form explaining how you plan to use GitHub. Note that if you use an institutional email your chances of getting accepted are higher.

4. Fastlane

If you're into mobile development, fastlane is sure to catch your interest.
Fastlane allows you to automate a lot of tedious task related to the development and release process of mobile applications.

It is an open-source platform developed along with Google's Firebase team.

The easiest way to build and release mobile apps.
fastlane handles tedious tasks so you don’t have to

5. Microsoft Imagine

This is the former Microsoft Dreamsparks, you have probably heard of it as it's been around for a while.

They provide lots of tools and services. From free Azure cloud services to VS Code tools, free Windows server OS, Xamarin and some training resources.

These are great resources if your preferred stack is .NET

Conclusion

As you can see there are lots of free resources, especially for students. So make sure you take advantage of these while you still can.

Do you know any great free resources I've missed on this list? Share them in the comments :D

How to deploy email signatures through Group Policies

José Coelho — Sun, 04 Nov 2018 21:30:11 +0000

A few years back I was working as a SysAdmin for a big company, which was going through a rebranding process. One of the targets for the rebranding was, of course, the corporate email signature which most of the 400+ employees were using.

So how do you deploy a new email signature for all employees? Do you just send them an email, and have them do it themselves? Well, that's an option but then you would have to handle the unstoppable help requests from the less tech-literate employees.

There has to be a better way.

Group Policies to the rescue

Let me set the scene here, I was working in a network with about 400 Windows workstations, and most of the infrastructure was Windows based as well. So it was clear to me Group Policies was the way to go.

I quickly came up with a plan, develop a PowerShell script, that could copy the signature to the user's workstation, and have it run every time a user logs in.

1. Creating a signature template

I got the new email signature and I had to create a template so that my PowerShell script would fill in the information later.

So this was my signature template (.html file) with placeholders stored on a shared location accessible by all users:

2. PowerShell script

I needed a script that would replace the user-specific information for each user, in this case, replace the user's name, job title, department, email, office and phone number.

# Gets the path to the user appdata folder
$AppData = (Get-Item env:appdata).value
# This is the default signature folder for Outlook
$localSignatureFolder = $AppData+'\Microsoft\Signatures'
# This is a shared folder on your network where the signature template should be
$templateFilePath = "\\server\signatures"

# Get the current logged in username
$userName = $env:username

# The following 5 lines will query AD and get an ADUser object with all information
$filter = "(&(objectCategory=User)(samAccountName=$userName))"
$searcher = New-Object System.DirectoryServices.DirectorySearcher
$searcher.Filter = $filter
$ADUserPath = $searcher.FindOne()
$ADUser = $ADUserPath.GetDirectoryEntry()

# Now extract all the necessary information for the signature
$name = $ADUser.DisplayName
$email = $ADUser.mail
$job = $ADUser.description
$department = $ADUser.department
$phone = $ADUser.telephonenumber
$office = $ADUser.physicalDeliveryOfficeName

Now that I have all the information about the user that I need, I have to replace it on the signature template and copy it to the user's local folder.


$namePlaceHolder = "[DISPLAY_NAME]"
$emailPlaceHolder = "[EMAIL]"
$jobPlaceHolder = "[JOB_TITLE]"
$departmentPlaceHolder = "[DEPARTMENT]"
$phonePlaceHolder = "[PHONE]"


$rawTemplate = get-content $templateFilePath"\template.html"

$signature = $rawTemplate -replace $namePlaceHolder,$name
$rawTemplate = $signature

$signature = $rawTemplate -replace $emailPlaceHolder,$email
$rawTemplate = $signature

$signature = $rawTemplate -replace $phonePlaceHolder,$phone
$rawTemplate = $signature

$signature = $rawTemplate -replace $jobPlaceHolder,$job
$rawTemplate = $signature

$signature = $rawTemplate -replace $departmentPlaceHolder,$department

# Save it as <username>.htm
$fileName = $localSignatureFolder + "\" + $userName + ".htm"

The last step is to copy the signature to the user's local folder:


# Gets the last update time of the template.
if(test-path $templateFilePath){
    $templateLastModifiedDate = [datetime](Get-ItemProperty -Path $templateFilePath -Name LastWriteTime).lastwritetime
}

# Checks if there is a signature and its last update time
if(test-path $filename){
    $signatureLastModifiedDate = [datetime](Get-ItemProperty -Path $filename -Name LastWriteTime).lastwritetime
    if((get-date $templateLastModifiedDate) -gt (get-date $signatureLastModifiedDate)){
        $signature > $fileName
    }
}else{
    $signature > $fileName
}

3. We got a signature

If this script runs successfully you should end up with a complete signature in your AppData folder, like so:

4. Set up a group policy

To finish off I set a new group policy and have this script run every time a user logs in.

It took a while until all users had the updated signature, as some of them where on holidays and some rarely logged in.

And that's why I love PowerShell :D

^{This is my first post... Leave me some feedback if you'd like ;)}