Utilities Blog by JuCa Cruz

Customize Jenkins SSH Agent for Windows

2024-08-31T17:39:00.008-04:00

I stumbled upon this challenge:

My team was using a Windows VM to act as a Jenkins Agent to build and deploy .NET apps

It works like a charm.

However, I would like to be 100% on Containers, so we decided to embark on the journey of dockerizing this VM.

Using as baseline jenkins/ssh-agent:windowsservercore-ltsc2022-jdk21 we extended that OOTB image by adding the required software installed on the VM:

Nuget 6.10
Visual Studio 2019 Build Tools
Visual Studio 2019 Test Agent
.NET Framework Developer Pack version 4.5.1 - 4.6.2
MSDeploy (webdeploy)

The main challenge we faced was to copy/paste some files into

C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\MSBuild\Microsoft\VisualStudio\v16.0

We kept on getting nasty errors like these each time we referenced that folder:

x86 : The term 'x86' is not recognized as the name of a cmdlet, function, 
script file, or operable program. Check the spelling of the name, or if a path 
was included, verify that the path is correct and try again.
At line:1 char:40
+ Get-ChildItem -Path C:\`Program Files (x86)\`Microsoft Visual Studio\ ...
+                                        ~~~
    + CategoryInfo          : ObjectNotFound: (x86:String) [], CommandNotFound 
   Exception
    + FullyQualifiedErrorId : CommandNotFoundException

Our solution was switching the Work Directory and we never looked back (or had to reference such folder)

WORKDIR C:\\'Program Files (x86)'\\Microsoft Visual Studio\\2019\\BuildTools\\MSBuild\\Microsoft\\VisualStudio\\v16.0

And that's how you work around that nasty error.

CI/CD pipeline on Jenkins using Docker

2024-07-24T07:00:00.005-04:00

Previously:

CI/CD pipeline on Jenkins - I

CI/CD pipeline on Jenkins - II

Now

I would like to document here what would it look like a similar setup running on Azure Container Instances (using Docker):

Login to Azure Portal
Select the appropriate Subscription to use
Activate the contributor role

Open Azure Cloud Shell
Let the fun begin! 🥳

Create Jenkins main node with persistent storage

Containers by default are stateless, so we need to prevent data loss at all cost.

By using persistent storage no matter how many times the container gets terminated and restarted, we will not lose any data;

The goal will be to have JENKINS_HOME (/var/jenkins_home) safely stored outside of the container.

# Change these four parameters as needed
ACI_PERS_RESOURCE_GROUP=myJenkinsResourceGroup
ACI_PERS_STORAGE_ACCOUNT_NAME=myjenkinsstorageacct1
ACI_PERS_LOCATION=eastus
ACI_PERS_SHARE_NAME=acishare

A resource group is a logical folder where we will store (group) all the items that belong to this project, this will help us to be more organized.

# Create the storage account with the parameters
az storage account create --resource-group $ACI_PERS_RESOURCE_GROUP --name $ACI_PERS_STORAGE_ACCOUNT_NAME --location $ACI_PERS_LOCATION --sku Standard_LRS

# Create the file share
az storage share create --name $ACI_PERS_SHARE_NAME --account-name $ACI_PERS_STORAGE_ACCOUNT_NAME

# Retrieve the storage key
STORAGE_KEY=$(az storage account keys list --resource-group $ACI_PERS_RESOURCE_GROUP --account-name $ACI_PERS_STORAGE_ACCOUNT_NAME --query "[0].value" --output tsv)

# Creation of our Jenkins main node
az container create --resource-group $ACI_PERS_RESOURCE_GROUP --name my-jenkins-main-01 --image jenkins/jenkins:latest --dns-name-label jenkins-main-ci --ports 8080 --azure-file-volume-account-name $ACI_PERS_STORAGE_ACCOUNT_NAME --azure-file-volume-account-key $STORAGE_KEY --azure-file-volume-share-name $ACI_PERS_SHARE_NAME --azure-file-volume-mount-path /var/jenkins_home --environment-variables 'JAVA_OPTS'='-Dorg.apache.commons.jelly.tags.fmt.timeZone=America/New_York'

After this, we should have a Jenkins main / master node up and running on ACI.

Create Jenkins Inbound Agent

As a good practice, we will not be executing any building jobs out of the main node but we will align to our Jenkins architecture.

Inside Jenkins main node we need to provision a new Node as a Permanent Agent:

Once completed the creation process on Jenkins main node, this is what the Status section will look like:

Unlike with main node, we decided to go for our own customized jenkins inbound-agent since we require certain additional tools as documented in previous posts.

Now going back to Azure Cloud Shell, you will need to execute the following create command:

az container create --resource-group $ACI_PERS_RESOURCE_GROUP --name my-agent-node-01 --image mywwwcontainerregistry001.azurecr.io/wwwcontainer/jenkins-inbound-agent-linux-image:0.0.2 --os-type linux --dns-name-label jenkins-node-01-ci --ports 443 --command-line "java -jar /usr/share/jenkins/agent.jar -url http://jenkins-main-ci.eastus.azurecontainer.io:8080 -secret <SECRET_GOES_HERE> -name build-agent-image-01 -workDir /home/jenkins/work -webSocket" --cpu 4 --memory 6

Some considerations

--command-line "java -jar /usr/share/jenkins/agent.jar -url http://jenkins-master-ci.eastus.azurecontainer.io:8080/ -secret <SECRET_GOES_HERE> -name build-agent-image-01 -workDir /home/jenkins/work -webSocket"

This parameter (--command-line) tells the container to execute this command(s) when starts, so it will try to connect to its main node as soon as it comes online.

The key here is to include the modifier -webSocket, otherwise it will not be able to communicate with the main node.

If everything went as planned, the agent will show online in a couple of minutes.

Why didn't you stick with the OOTB Jenkins Inbound agent for linux like you did for the main node with jenkins/jenkins:latest?

If you have been paying attention and had read my previous posts, we need some special software to be installed on the agent to make it possible to compile and deploy SFCC code base:

rsync
7zip
maven (optional)
git
curl
sudo
NodeJS 10.24.1
NPM
typescript
sfcc-ci

Therefore we need a custom image, but since I am not a big fan of reinventing the wheel, I extended the OOTB agent and this is the result.

If you are the type of fellow who would like build the docker image from scratch, here it is the Dockerfile for your own amusement:

FROM jenkins/ssh-agent:latest

#Switch to root
USER root

# Install rsync, 7zip, maven, git, curl & sudo
RUN apt-get update \
&& DEBIAN_FRONTEND=noninteractive \
apt-get upgrade -y \
&& apt-get install -y rsync p7zip-full maven git curl sudo

# Clean up APT when done.
RUN apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*

#Setup NodeJS & NPM
ARG NODE_VERSION=10.24.1
ARG NODE_PACKAGE=node-v$NODE_VERSION-linux-x64
ARG NODE_HOME=/opt/$NODE_PACKAGE

ENV NODE_PATH $NODE_HOME/lib/node_modules
ENV PATH $NODE_HOME/bin:$PATH

RUN curl https://nodejs.org/dist/v$NODE_VERSION/$NODE_PACKAGE.tar.gz | tar -xzC /opt/

#Install Typescript - test
RUN npm install -g typescript

#Install SFCC-CI
RUN npm install -g sfcc-ci

#Create "alias" (soft link) for 7z
RUN ln -s $(which 7z) /usr/bin/7zz

#Switch to jenkins
USER jenkins

Now it's up to you to try and see the magic with your own eyes!

CI/CD Pipeline for SFCC - Jenkins - part II

2024-02-04T15:58:00.001-05:00

On a previous post, we went over setting up a CI/CD pipeline for SFCC using Windows.

What's next?

Let's give it a try with Linux!!!

Why Linux and not Windows?

Linux is much more efficient in terms of managing and executing resource intensive tasks like compiling and packaging code projects.

Historically, Linux is 30-40% faster when performing such tasks, a few additional elements to consider:

Linux performs faster git operations - Linux performs command line git operations faster than Windows (as evidenced by ci.jenkins.io git client plugin automated tests requiring 12 minutes on Linux and 22 minutes on Windows)
Fewer locking issues - Linux file system locking semantics are more forgiving than Windows file system locking semantics. It is more likely that a "busy file" on Windows will disrupt the Jenkins controller than it will on Linux.
License cost.

Our journey has taken us from a process that used to take 3-4 hours when we were leveraging a vendor owned and managed implementation to this:

So expect at least to achieve better times than with Windows.

If you are still with me, this is the translation into shell:

Code build

#!/bin/bash

export PATH=/usr/local/bin/7zip:$PATH

export PREFIX="B2C"

export COMMIT_SHORT="${GIT_COMMIT::7}"

export BRANCH=${GIT_BRANCH//\//_}

export BUILD_VERSION=${PREFIX}_${BRANCH}_${BUILD_NUMBER}_${COMMIT_SHORT}

echo "***Deleting Folders to skip"

rm -rf ./cartridges/useless_folder

echo "***Installing NPM & Build project"

npm install --silent

npm run build --silent

echo "***Cleaning up manually build folder"

#Since workspace is always cleaned, this step is optional

rm -rf ./$BUILD_VERSION

mkdir ./$BUILD_VERSION

echo "***Preparing to package project - rsync"

#skipping files: .project *.java *.docx *.cpp *.php

#skipping folders: junk

rsync -rq --exclude={'.project','*.java','*.cpp','*.php'} --exclude={'junk'} ./cartridges/ $BUILD_VERSION

echo "***Packaging deployable artifact - 7z"

#"-mx[N]" specifies compression level

#"-mmt[N]" set number of CPU threads

7zz a $BUILD_VERSION.zip $BUILD_VERSION -mx9 -mmt16

Code deploy

Nothing new here, feel free to reuse the one we did on our first iteration.

Have fun!

CI/CD Pipeline for SFCC - Jenkins - part I

2023-12-25T00:00:00.010-05:00

Story time: Setting up an efficient CI/CD Pipeline for Salesforce Commerce Cloud

A little bit of context

Our main vendor was running this capability, which enabled the team to run deployments once per week or maybe every other day. That seemed great as the status quo;

However, waiting for a build to complete in 3-4 hours doesn't work for me, the goal was to enable the team to deploy at least every hour or less.

Following a nice combination of creativity plus thinking outside of the box, we setup a pipeline which deploys under 15 minutes (12) to 4 different Instances of SFCC (DEV, INT, QA and STG).

I am not going to showcase what it looked like in the past, because water under the bridge

Overview

Jenkins is an open source automation server. It helps automate the parts of software development related to building, testing, and deploying, facilitating continuous integration, and continuous delivery. It is a server-based system that runs in servlet containers such as Apache Tomcat.

Build great things at any scale

Jenkins provides hundreds of plugins to support building, deploying and automating any project.

We decided to set it up on a VM in Azure since that's what we have. We started with a Windows VM for the following reason, we wanted to mirror as much as possible the original setup done by our vendor so we could leverage if there was any institutional knowledge.

In a future iteration we might use Linx and why not, a Dockerized image.

The fun part is in the job

Be organized

Define a unique and short name in order to avoid issues with file system limitations

Add a meaningful description
Define a clear build strategy - build retention - this will help you to manage your disk space
Reference your GitHub repo

Make use of Display Name

Enable CI/CD! - This is where we let Jenkins do the checking if there is a new change that needs to be deployed - currently we set that value to 30

Always delete your workspace in order to prevent old code to be present, we always need a fresh copy of the repo
Add timestamps to the Console Output - they are super helpful
Clean up your workspace, but be selective so it will be fast

Use secret bindings (no hardcoded passwords!)

Add your own build steps. Since you-all came to see the cooking recipe for SFCC Deployments, here it is:

The steps are quite self explanatory, however one pre-requisiten is to have installed SFCC-CLI

Windows batch commands

:: Setting variables
call set PREFIX=DEVOPS
call set PATH=%PATH%;C:\Program Files\7-Zip
call set COMMIT_SHORT=%GIT_COMMIT:~0,7%
call set BRANCH=%GIT_BRANCH:/=_%
call set BUILD_VERSION=%PREFIX%_%BRANCH%_%BUILD_NUMBER%_%COMMIT_SHORT%

:: Delete Folders to skip
call rmdir /S /Q cartridges\useless_folder

:: Install NPM & Build project
:: --silent flag suppress output
call npm install --silent
call npm run build --silent

:: Package build
:: Since workspace is always cleaned, this next step is optional
call rmdir /S /Q %BUILD_VERSION%
call mkdir %BUILD_VERSION%

:: Robocopy
:: skipping files: .project .tern-project .gitignore README.md *.java *.c *.php
:: skipping folders: .settings junk
call robocopy cartridges %BUILD_VERSION% /E /Z /ZB /R:5 /W:5 /TBD /NP /V /MT:16 /XF .project .tern-project .gitignore README.md *.java *.c *.php /XD .settings junk

:: 7z
:: "-mx[N]" specifies compression level
:: "-mmt[N]" set number of CPU threads
call 7z a %BUILD_VERSION%.zip %BUILD_VERSION% -mx9 -mmt16

Shell commands

#Setting variables export PREFIX="DEVOPS" export TARGET_INSTANCE_DEV="development-domain.demandware.net" export TARGET_INSTANCE_INT="integration-domain.demandware.net" export TARGET_INSTANCE_QA="cert.qa.domain.demandware.net" export TARGET_INSTANCE_STG="cert.staging.domain.demandware.net" export COMMIT_SHORT="${GIT_COMMIT::7}" export BRANCH=${GIT_BRANCH//\//} export BUILD_VERSION=${PREFIX}${BRANCH}${BUILD_NUMBER}${COMMIT_SHORT} echo "DEPLOYING $BUILD_VERSION TO $TARGET_INSTANCE_DEV, $TARGET_INSTANCE_INT, $TARGET_INSTANCE_QA and $TARGET_INSTANCE_STG" #Login into SFCC npx sfcc-ci client:auth --selfsigned $SFCC_CLIENT $SFCC_CLIENT_SECRET --renew #Deploy package npx sfcc-ci code:deploy $BUILD_VERSION.zip -i $TARGET_INSTANCE_DEV npx sfcc-ci code:deploy $BUILD_VERSION.zip -i $TARGET_INSTANCE_INT npx sfcc-ci code:deploy $BUILD_VERSION.zip -i $TARGET_INSTANCE_QA -c $SFCC_TEST_REALM_CERT -p $SFCC_TEST_REALM_CERT_SECRET npx sfcc-ci code:deploy $BUILD_VERSION.zip -i $TARGET_INSTANCE_STG -c $SFCC_REALM_CERT -p $SFCC_REALM_CERT_SECRET

Some things to consider, we leveraged P12 Cert to deploy to our QA and STG environment to make sure we take advantage of 2FA.

So there you have it.

Feel free to use this as your baseline and please share your refined versions.

Contractors vs Agencies

2023-10-27T22:00:00.004-04:00

It's been almost been a year since I switched jobs, it has been a fun/exciting /frustrating/<placeholder for more emotions> journey, and besides the logical and expected differences between jobs.

There is one thing that has been quietly consuming my idle time: This company loves their agencies!

When there is no budget to hire Full Time Employees or support to do that altogether, the workaround is to hire Contractors, although is easier to get more people from an existing "Partner", however I tend to steer away from that strategy in order to build new practices or even increase velocity;

Besides the elephant in the room

These are my reasons on why I diversify my portfolio of partners and approaches on how to grow teams:

Agencies have an incentive to create hard boundaries and push towards a "feature factory" culture

This way they'll sell more "resources". Making roles more granular helps selling more profiles.

For example:

1 Project Manager
2 Backend Developers
2 Front End Developers
2 QAs

When it could be just 2 or 3 senior engineers!

With such segregation of responsibilities, each team member can also be more junior on average, and the non-senior profiles are the ones where agencies make the highest margins.

This translates into suddenly a team of 10 or 15 people, without actually shipping much value.

Agencies don't have an incentive for increasing code quality standards

Clunky QA and Deployment processes are an opportunity for them to sell the people who operate them. Why should they push for automated CI/CD? They would lose business by doing it!

Issues in Production mean more bug tickets, regression tasks, triage calls, etc. That's an scope increment they'll happily bill for.

Also there's an incentive to accept loosely defined tasks, and not go deep to define all edge cases ahead of development. This will generate more work down the road.

Bottomline, it will hurt the client's pockets!

Agencies create barriers and bureaucracy

This makes super easy to add new people to the team. But not so easy to downscale when needed. Or to fire that person who's not performing. Unless, the person responsible for the relationship decides to go over a lengthy process to discuss why you don't want certain individuals (I did this and it's worth the effort)

Contract clauses like minimum tenures and so on can really hinder nimbleness in a small team (your legal and procurement team will help you here).

Are GitHub Copilot and GPT-4 the cure for all our software engineering bottlenecks?

2023-03-22T09:25:00.003-04:00

As a leader I decided to take for a spin such technologies before fully embracing them or even asking my teams to play with them. And the lines below summarize my personal journey and my 2 cents on the matter:

On average, developers produce or change 30 lines of code a day. Most of that time is spent on reading and trying to understand code so they can change it.

It’s almost a 10:1 ratio of reading versus writing code.

If I knew a DB table was going to be read 10x more often than writing to it, I wouldn’t optimize it for write speed.

That’s why Kent Beck’s Simple Design prioritizes:

Passes the tests
Reveals intention (should be easy to understand)
No duplication (DRY)
Fewest elements (remove anything that doesn’t serve the three previous rules)

There are wording variations on those rules, but I got those specific words from this Martin Fowler post. As he notes, “The rules are in priority order, so passes the tests takes priority over reveals intention”.

Developers who are disciplined will spend at least half their time refactoring the code to satisfy 2–4 as best as they can. We spend a lot of the remaining “coding” time writing tests.

I have experimented doing Test-Driven and Test-After development with GitHub Copilot and GPT-4, and they just got in the way.

Mentoring developers vs Coding, I realised that it’s better to turn Copilot off. It was just noise!

Create a Windows 10 Image on a USB on Mac

2022-10-05T12:28:00.003-04:00

While doing some casual browsing in a store, I stumbled upon this old laptop for practically nothing, so I decided to buy it.

The challenge now was to reimage it and since I own a Mac, the process was not going to be so straight forward.

Thankfully, after further research I was able to come up with a set of steps that any fellow Mac user can follow to take care of this challenge.

Download the appropriate Windows Installation Image (ISO file) from their website
Mount the image with Finder (double click)
Insert target device (USB)
Open Terminal and run these commands

diskutil list

diskutil eraseDisk MS-DOS "WINUSB" MBR diskN

Where diskN is the proper identifier for your device, in my case it was disk5 (be careful with this step, otherwise you will format the wrong disk)

rsync -avh --progress --exclude=sources/install.wim /Volumes/CCCOMA_X64FRE_EN-US_DV9/ /Volumes/WINUSB

This step will copy all files except one from the ISO image into your newly created USB Bootable drive. The reason why we skip that file is because it's massive and Mac will throw an error (it won't allow us to copy it).

In order to proceed with such massive file, you need to use WimLib, and the easy way to install any package on a Mac or Linux based system is via Homebrew.

Once you have installed Homebrew proceed to install WimLib via the appropriate Homebrew Formulae.

Now you are ready for the next and final command.

wimlib-imagex split /Volumes/CCCOMA_X64FRE_EN-US_DV9/sources/install.wim /Volumes/WINUSB/sources/install.swm 4000

Once you have the image ready, just plug it in and boot from USB and just follow the installation process.

Note:

If you face an issue with one of the files being corrupted while performing the installation, no worries, sometimes happens. I faced this issue a couple times, you just need to rinse and repeat.

React + GraphQL App using AWS Amplify

2020-10-10T07:00:00.001-04:00

A little bit of context

In the past few years I have been experimenting a lot with AWS based technologies and it's been quite the ride.

Recently I stumbled upon this website and it was quite the reading so I decided to give it a try and share my experience.

What is it?

AWS Amplify is a service provided by Amazon Web Services which gives the ability to create end to end solutions for mobile and web platforms leveraging AWS.

It also provides an easy way to configure features called modules such as named authentication, storage, backend API, hosting and deployments.

Next Steps

In this post I am going to build and deploy a React application with GraphQL.

Pre-Requisites

Make sure you have an account with AWS. It's free.

If your company provides you with a DEV account, first make sure you have the service enabled, otherwise, there is no shame in getting your own personal account.

If you decide to sign up, allow a few hours to get all services enabled, otherwise you will be blocked as you make progress.

Now you should be all set.

Install and configure Amplify CLI

npm install -g @aws-amplify/cli

Now in order to configure the installed Amplify with our AWS account issue the below command.

amplify configure

This will prompt a series of questions that we need to answer.

First, it will ask us to log in to our AWS account using the web console.

The next important question is the IAM user that it will create for our Amplify CLI tool.

After specifying a name for the user it will again redirect us to the IAM console where we need to provide necessary permission policies for our user.

Here make sure to add AdministratorAccess policy to the user. Then go to Security Credentials tab and create an access key for this user and remember to download and store credential details. Back in the console as next steps, it will ask for this accessKeyId and secretAccessKey. Now our configuration for Amplify CLI is done.

Create a React application

For the creation of a new react application issue the following commands.

npx create-react-app amplify-react-sample
cd amplify-react-sample
npm start

If everything went smoothly in localhost:3000 it should show the newly created react application.

The next step is to add aws-amplify to our react application as a dependency. This package will have the functionality of doing all the configurations on Amplify from our react code.

npm install aws-amplify @aws-amplify/ui-react

Next, let’s initialize an Amplify project for our react application.

amplify init

Again we will be prompted to answer a series of questions. For the project name, you can give any name you want. For the type of application select javascript and for the framework select react. For other questions, we can leave the default values since we are not going to change the react build and run scripts inside our application.
The following modifications in our project will be done during this step.

A new folder named amplify will be created at the root level of the project. This stores every configuration related to our backend (AWS resources). (In this article we are going to add authentication and GraphQL API). As we add more amplify features configurations related to those features will be stored inside this folder as Infrastructure As code.
A file called aws-exports.js will be created in the src directory that holds all the configuration for the services that we will create with Amplify. For now, it only contains region information because we are still not using any Amplify services.

At the same time on AWS a cloud project will be created which we can access through the Amplify console. The console also gives some other additional configuration options as well for our application.

Add Authentication

For authentication, Amplify uses AWS Cognito as the main authentication provider. AWS Cognito provides many features like authentication, user registration, account recovery, and many more. In order to add Cognito to your app, follow the next command:

amplify add auth

Again we will be prompted with questions for our authentication configurations. We will choose the default configuration for security configuration. (if we want we can update this later by running amplify update auth).

For the sign-in option, you can choose either username or email.

And that’s it, now we have our authentication module created for us. But before testing it in our application we need to push this configuration to Amplify. To do that simply issue the following command in the terminal.

amplify push

This command will create the required configurations on Amplify and Cognito on AWS and will also edit our aws-exports.js file with Cognito auth configurations. The next step is to use this Cognito authentication in our react application. For that first, we need to import the Amplify module for our application. Edit index.js file to import Amplify and configure Amplify module using the configurations in aws-exports.js file.

import Amplify from 'aws-amplify';
import awsconfig from './aws-exports';
Amplify.configure(awsconfig);

Now we can use the auth module in our application. Go to app.js and first import the below modules.

import { withAuthenticator, AmplifySignOut } from "@aws-amplify/ui-react";

Next, wrap our App component with WithAuthenticator. Here AmplifySignOut is a component provided by amplify-react where it acts as a sign out button.

Now that we have added the Amplify authentication in our react application let’s start the server and test whether it works.

npm start

and go to the browser.

Now it should display a sign-in page when we try to access localhost:3000. If you can see the above page that means our authentication is set correctly. The next step would be to create a user in our Cognito user pool. You can either create a user through the IAM console or by clicking on Create account.

Now try to login using the user we created. If everything works just fine let’s move to the next task.

Add GraphQL

Amplify supports creating serverless backend APIs using AWS AppSync. AppSync supports both REST and GraphQL API frameworks. For now we are going to use AppSync GraphQL API.

Before adding our backend GraphQL API let’s do some modifications on our react application in order to show data in a table.

In the above code, I am using material-ui for the creation of the table which you can install using

npm install @material-ui/core

The code only displays a table where for now we have defined a set of data inside fetchActors() method. (Make sure to import the Home component in App.js as well)

Now, let’s make this dynamic using GraphQL to retrieve actor information from an API. To add a GraphQL to our application simply issue the following command in the terminal.

amplify add api

For the questions you will be asked to provide select service as GraphQL and for authorization choose

Amazon Cognito User Pool.

Next for the schema template select Single object with fields. This will automatically create a simple GraphQL schema for us. Next when you asked to edit the schema press Y.

This will open our schema.graphql which is created automatically. There we can see the schema with model Todo already created.


type Todo @model {
  id: ID!
  name: String!
  description: String
}

Now let’s modify this schema for our use case where our model will be Actors.


type Actor @model {
  id: ID!
  firstName: String!
  lastName: String
  age: Int
  movies: [String]
  gender: String
}

The next step is to push this GraphQL api to Amplify where it will be get created on AppSync. Issue below command to push the API.

amplify push

Now we will be prompted more questions. Select the language target to be Javascript and make file pattern the default. Later it will ask to generate all GraphQL operations for our schema. Make sure to enter Yes for this as this will auto-generate Query and Mutation for our Actor model.

This will create our GraphQL API on AppSync. Our database will also get automatically created on AWS DynamoDB. Also, it will create a new folder inside the amplify folder named backend. Our Actor schema and other AppSync related configurations can be found inside this folder.

At the end, we will be provided with the GraphQL endpoint which we have configured using Actors schema. Now if we go to the AppSync console we can see the newly created Actors API.

GraphQL client included so we can test all operations.

Now let’s start adding GraphQL API to our React application.

First, we need to import Amplify, API, graphqlOperation modules in our Home component.

import Amplify, { API, graphqlOperation } from 'aws-amplify'

Next, we need to import Query and Mutation we are going to perform in the application. In our case Query is listActors and Mutation is createActor. We can get these Query or Mutation from either AppSync console or in the aws-schema.graphql file inside backend/api folder


import { createActor} from './graphql/mutations' 
import { listActors} from './graphql/queries'

Also, make sure to configure imported Amplify using the correct configurations.


import awsExports from "./aws-exports";
Amplify.configure(awsExports);

Below is the function that we are going to use for fetch actors.


const fetchActors = async () => {
        try {
            const actorData = await API.graphql(graphqlOperation(listActors))
            const actors = actorData.data.listActors.items
            setActors(actors)
        } catch (err) { console.log('Error when invoking graphqlOperation: listActors') }
    }

Now the last thing we need to do is calling this fetchActors() function from UseEffect. Replace previously called fetchActors() with this one.


    useEffect(() => {
        setActors(fetchActors())

    }, [])

Now make sure to leverage the GraphQL client to add a few records. Once that's done we can verify in our App.

Next, let’s try to add actors using our react application. For this, we are going to use addActor Mutation which we already imported.

      
const addActor = async () => {
        try {
            if (!formState.firstName || !formState.lastName) return
            const actor = { ...formState }
            setActors([...actors, actor])
            setFormState({ firstName: '', lastName: '', age: 0, movies: '' })
            await API.graphql(graphqlOperation(createActor, { input: actor }))
        } catch (err) {
            console.log('Error when invoking graphqlOperation createActor:', err)
        }
    }

Apart from creating addActor() function we need to have input fields as well. Below is the fully completed code for the Home component.

Now our page will look like this:

Deploy and host on Amplify

Let’s add the hosting module for our application by issuing the following command.

amplify add hosting

One more time we will be prompted with several questions. For the plugin select Hosting with Amplify Console and for the type select Manual deployment.

Finally we need to publish this module to Amplify.

amplify publish

After a few minutes, all infrastructure will be get created and we will have an assigned URL.

You can go ahead and check it to make sure everything works as it should be.

As next iteration we could add CI.

SSO with Brightcove Gallery

2018-04-25T20:36:00.000-04:00

If you haven't heard about Brightcove Gallery, in a few words is just platform that allows you to stream video efficiently and with great quality.

One of the challenges we faced was to integrate this platform with ours. Despite the fact that they have decent documentation, as usual, the fine details are not present. If it was that easy anyone would do it :)

In order to keep things simple we just have to pay attention to these details:

After you have created your SSO configuration on Access Control and on your SSO server you have setup your IdP.

Go to your site settings in your project/experience and link your site to your newly created Access Control

According to the documentation this should be all (yay!)

However when testing you will get a 404 from Gallery (o_O)

Why me???? :O

This is the trick:

Double check your SSO settings on your IdP settings

Our endpoint matches what Gallery has in ACS URL Override. But we have a site which has its own URL

Bingo! Let's use that URL in our Assertion Consumer Service URL, keep the /login/callback

And success!!!

C++ for Kids

2018-03-22T22:30:00.000-04:00

Eventually I will find Java for Kids :)

Can your CTO still code?

2018-02-04T10:30:00.000-05:00

Chief technology officers need to keep their sleeves rolled up and maintain their coding skills to better challenge their teams of developers.

Many chief technology officers study technology, consider different architectures and challenge their team to deliver products and services. The problem with this approach is that many CTOs today no longer maintain application development proficiencies.

The CTO is often at the mercy of many differing opinions within their organization without the important understanding, in some level of depth, the challenges, capabilities or even limitations that certain platforms present.

Worse yet, when a CTO completely relies on the advice of his or her engineers, that advice may simply be based on the preexisting comfort levels of the designers, programmers and architects.

When you’re consistently taking the word of others and haven’t maintained enough skill to perform basic discovery for yourself, you, as a CTO, are significantly diluting the power you have in driving true digital transformation for your company.

Continue reading

What happens when you messed things with GitHub?

2018-01-08T12:46:00.000-05:00

Git is hard: screwing up is easy, and figuring out how to fix your mistakes is fucking impossible. Git documentation has this chicken and egg problem where you can't search for how to get yourself out of a mess, unless you already know the name of the thing you need to know about in order to fix your problem.

Continue reading here

Partnering with Amazon

2017-12-23T21:19:00.000-05:00

Amazon.com
Sounds impressive, doesn't it?

Unfortunately, integrating with them it could be a challenge, I guess the bigger a company becomes the more bureaucratic and slow becomes.

My experience dealing with them it's been less than pleasant and I can't complain about personalities but more about constant rotation of personnel on their side, slowness (every little thing with them takes 2 weeks that become 4 and sometimes 6) and lack of clear communication, you can't even talk to an actual Engineer.

I guess it's the price you have to pay when doing business with them.

Yeah, I know, this entry is more a way to blow some steam rather than providing useful insights.

My only advice I can give about Amazon.com is be patient and keep your business involved so you don't get dinged.

Windows NT Security

2017-11-22T12:30:00.000-05:00

JS Frameworks with Salesforce

2017-10-31T21:29:00.000-04:00

As I mentioned on previous entries, Salesforce has its good and bad things, but coming from a Java School, I still firmly believe that is not very Developer Friendly.

One of the things I wanted to try was to implement a Rich UI using JavaScript frameworks and either simple backend or APIs. However, Salesforce makes it kind of complicated.

The main challenge is around managing static resources, since all your code will be mostly in a bunch of JS files which have to be packaged and deployed in a Zip file as static resource.
But if you are patient enough you could implement something cool with a Visualforce page that might look like this:

On this particular approach we mixed Apex Remote Objects (Remote Object Model) with React. But that doesn't mean that you can't be creative and go for something more complex like using @RemoteAction in your controller methods.

Yeah, we could have tried something more Salesforcy like Lightning, but that's not what the cool kids use nowadays :D

Basics of Java Garbage Collection

2017-09-16T12:50:00.000-04:00

It’s an old joke from the time when Java was new and slow compared to other languages. Over time, Java became a lot faster. Today it powers many real-time applications with hundreds of thousands of concurrent users. These days, the biggest impact on Java’s performance comes from its garbage collection. Fortunately, in many cases, it can be tweaked and optimized to improve performance.

For most applications, the default settings of the JVM work fine. But when you start noticing performance issues caused by garbage collection and giving more heap memory isn’t possible, you need to tune and optimize the garbage collection. For most developers, it’s a chore. It requires patience, good knowledge garbage collection works and an understanding of application’s behavior. This post is a high-level overview of Java’s garbage collection with some examples of troubleshooting performance issues.

Continue reading here

TLS 1.0 has been disabled - Salesforce

2017-08-24T08:00:00.000-04:00

First things first: What's TLS and why did Salesforce moved to 1.x and had to disable TLS 1.0?

TLS 1.0

What kind of improvements brings to the table TLS 1.1?

Added protection against cipher-block chaining (CBC) attacks.
Support for IANA registration of parameters.

Clearly TLS 1.1 is more secure (compared to 1.0).

The things that can be affected in your instances are as below:

Web requests to Salesforce URLs that require authentication.
Web requests to the login page of a My Domain.
Web requests to Community or Force.com sites.
Web requests to Customer and Partner portals.
Web to lead, web to case, and web to custom object requests API requests to Salesforce Callouts using Apex to a remote endpoint.
Workflow outbound messaging callouts to a remote endpoint Callouts using Lightning Connect to a remote endpoint AJAX proxy callouts to a remote endpoint.
Delegated authentication callouts to a remote endpoint Mobile apps developed with Salesforce Mobile SDK need to upgraded to SDK v4.

That's a big list and if you are an enterprise org, then I am sure you would have at least one of the above things in your org and you may find it to be broken if you don't take any action.

So below are some of the suggestions to fix this issue:

If you are using force.com migration tool and ANT process be on a latest ANT version.
If you are using Java 7, upgrade to Java 8 since Java 8 by default uses 1.2
If have an integration running, like WebMethods, there will be setting to disable TLS 1.0 or to enable TLS 1.2 (see -Dhttps.protocols=TLSv1.1,TLSv1.2).
You can disable TLS 1.0 in your browser, but I'd rather upgrade :)
Also look for specific configuration if you want to explicitly force tools to use TLS 1.1 or TLS 1.2

Hopefully this sheds some light and helps you reduce the pain of dealing with this.

The evolution of scalable microservices

2017-07-14T14:27:00.000-04:00

Today’s enterprise applications are deployed to everything from mobile devices to cloud-based clusters running thousands of multi-core processors. Users have come to expect millisecond response times and close to 100% uptime. And by “user” I mean both humans and machines. Traditional architectures, tools and products simply won’t cut it anymore. To paraphrase Henry Ford’s classic quote: we can’t make the horse any faster, we need cars for where we are going.

Continue reading

Setup Lombok with STS/Eclipse based IDE

2017-06-24T23:30:00.000-04:00

For those of you who haven't heard about boilerplate code, you can check this link
Now that you already know what's that we found this little library

You can add it to your Maven projects easily, however adding it to your Eclipse is a challenge, especially if you are not using barebones Eclipse like me, who happens to use STS and initially it didn't work:

Why it doesn’t generate getter and setter like in the video? I already installed that thing like 3 times and nothing :(

Well, the solution for me was this:

Paste the JAR manually into MacOS folder

Add the option
to the file STS.ini

Finally you NEED to close the STS/eclipse and start again. (Restart doesn’t take effect)

Once you’ve done close and start STS. You’ll see the getter and setter is autogenerated.
In case you see any compilation errors, just clean and build your project.

Voila!

Geo location fields throwing "No such column 'XXXc' on entity 'XXXXc' during deployment.

2016-01-12T16:34:00.000-05:00

While performing a routine deployment to Salesforce we encountered a really weird issue:

We double checked if we have missed any permissions or something else but no, everything was ok.

In order to keep this story short, we found our smoking gun:

If we comment that line, at least the SOQL, the issue automagically gets fixed. What???

After more research and dozens of interactions with Salesforce support we found that this is a known issue with the plattform:

https://success.salesforce.com/issues_view?id=a1p30000000SpfnAAC

Salesforce has a workaround for this, but it will require to have Salesforce helping us to deploy this line after a regular release every time.

In other words:

We deploy all our changes
Ask Salesforce to deploy that code

Then in a subsequent release:

We comment that line and deploy (reference to geolocation is gone)
Deploy any additional code - BAU
Uncomment line on lower environment
Ask Salesforce to deploy that code referencing geolocation
And repeat this forever until Salesforce fixes that issue

Convert that query into a String:

By doing this we tricked the Compiler, so the validation that breaks the whole deployment never is executed, therefore our code is just executed/compiled during runtime.

Voila!!!

New Baby

2016-01-07T09:50:00.000-05:00

I know, this is not technical stuff, but I'm really happy and excited about it.

Soon (between this week and the next one) I will become a Dad for the second time!!!

Salesforce page keeps loading forever

2015-11-13T15:48:00.000-05:00

If you are poking around Salesforce, you might be one facing a lot of challenges and at the same time hitting your head against the wall multiple times.

Have you heard that Log levels have a big influence on your whole Org performance?
There is a way which might help to you to add a little boost to your apps developed on this not very friendly developer platform:
Change Log Levels using your Developer console.

But what happens when your developer console is so slow which doesn't allow you to change anything :(

There is a solution for that:

Launch the developer console and under "Query Editor" type the following query

select Id from TraceFlag

Then check the "Use Tooling API" checkbox and click "Execute."

After that select all the resultant rows and click "Delete Row."

Now you should be able to change the log levels. You may have to refresh the developer console page and good as new.

Spotify Engineering Culture

2015-06-24T00:00:00.028-04:00

Below there are a couple ofa short animated video describing Spotify’s engineering culture (also posted on Spotify’s blog).

This is a journey in progress, not a journey completed, and there’s a lot of variation from squad to squad. So the stuff in the video isn’t all true for all squads all the time, but it appears to be mostly true for most squads most of the time.

Here’s the whole drawing for both videos:

JBoss AS 7 not accepting remote connections

2014-12-19T16:05:00.001-05:00

For those who use JBoss AS 7 and want to connect to your application using the IP or server name from a computer in the intranet, you need to do this:
This is for Dev Environments only!
The answer is... Change the 127.0.0.1 (localhost) to 0.0.0.0 in standalone.xml

Apex Component error: Element type "input" should be followed by either attribute specifications, ">" or "/>"

2014-11-07T16:25:00.000-05:00

Not sure if you have faced this situation, but let's see what we're trying to accomplish.

Scenario Display 2 radio buttons, one unchecked and another one checked based on the value of a variable.

How was developed
For educational purposes I'll just show 1 radio button :)
Looks simple, however we got the weird error message listed as title of this post.

Solution
After thinking carefully and asking salesforce support, we end up with the same solution
In order to display 1 radio button only, we have to write code for 2 radio buttons!

I hope this saves you valuable time.