Innovation

Innovation and creativity

Innovation and creativity come from experimentation, play and open feedback. TUXSOL is more than happy to take on proof of concept (POC) user stories and projects to help build your automation pipelines and get your infrastructure and applications running in the cloud or on-prem and help move your security LEFT.

More on Shift Left here

Future and Ethics

The future is coming and we all need to start getting ready for it. It’s going to be a hell of a ride. We all need to be conscious of what technology choices are being made, by whom and why, and there potential impact on us and society. Join the debate, get involved, understand the technology, ask questions and help define the way ahead.

Cloud native technology

For the current CNCF landscape go here: https://landscape.cncf.io/

Coding principals for automation

This is simply a list of some approaches/steps that have been found helpful when building enterprise system automation. Please note none of these are new but hopefully you may find the list useful. These points have been picked up from real world experience and by working with great colleagues and teams over the years.

• Start by understanding the workflow
• Consider Automation scope and granularity inline with the risks
• Identify key stages
• Identify system integration requirements (vaults, IPAM, CMDB, APIs etc)
• Do the hard stuff first, the pretty stuff second
• Make test systems (containers, VMs, hardware devices) available from the start
• Continuous integration: build and test from the start (try Molecule)
• Start small
• Always have working code in Main
• Iterative development: -> design > build > test > refactor/tune > repeat >-
• Develope in small steps testing all the way
• Consider state present / absent for automation tasks
• Consider making your configuration or service automation tasks CRUD
• Don’t rush to a solution, communicate at each stage
• Use edge-cases to understand requirements
• Write readable, reusable and modular code
• Parameterization (don’t hard wire stuff)
• Don’t repeat yourself (DRY)
• Keep it simple (KISS)
• Do one thing and one thing well (UNIX philosophy)
• You aren’t gonna need it (YAGNI)
• Code by convention, convention over configuration
• Impose strict code review via pull requests
• Impose strict repository house-keeping removing feature branches after merging
• Use clear commit messages, squash unnecessary commits in branches before merging
• Impose strict code versioning and use git tags
• Use Semantic Versioning
• Keep secrets and credentials secret with correct use of vaults, no-logging options etc
• Consider using feature toggles
• Lint before committing use pre-commit hooks
• What’s in a name? JustAbout everyThing so-be-consistent inYourFile and variable_naming
• Use a naming convention
• Use declarative languages to define the desired end-state
• Ensure and test impotency
• Use roles to group related tasks
• Create or use collections of related modules
• Use existing collections and modules before creating custom solutions
• Leverage an IDE, using extensions and shortcuts to increase your productivity, try Copilot
• Style for python use: black PEP 8 compliant opinionated formatter
• Don’t forget PEP 20: The Zen of Python (import this)
• PEP 20 is explained a little here
• Document your code and pipelines with the help of versioned schematic diagrams
• Use automation to validate, report and log updates and deployments
• Remember automation code needs to be maintained just like any other software

So why automate?

• Continuous integration (build and test)
• Continuous Deployment (manage releasing updates and fixes)
• Reduced manual errors and build consistent environments
• Move from pets to cattle
• Reduce the time required for a change window (work done up front)
• Release management (versioning and rollback)
• Integration with change management
• Limit and monitor system access (JIT access)
• Enforce configuration (remediation runs)