New challenges for broadband providers
Large broadband providers are increasingly relying on software-based solutions for their access networks: The systems previously purchased from external service providers are to be replaced by open, disaggregated, and highly automated systems. This enables more cost-efficient and more scalable platforms which, in particular, are more flexible to operate and maintain.
Current approaches and technologies are used for this, such as microservices in Docker containers, Kubernetes, "Continuous Integration" and "Continuous Deployment" (CICD).
The conversion of the broadband infrastructure to a software-based approach requires the extensive involvement of agile teams with expertise in both software development and DevOps as well as in the area of network infrastructure.
We support the test automation, release management and quality assurance (QA) areas of one of these innovative transformation projects: Our teams in the project combine many years of experience in the management of software projects with practical developer expertise in DevOps and networks.
In this post, we take a closer look at the work of our QA team.
Our focus: Ensuring code quality
Code is the crucial artefact of every project in the field of software-defined networking (SDN). The developer teams involved usually bring their own respective quality standards for code with them. In order to ensure smooth cooperation within the project, it is necessary to unify these standards and, in particular, to adapt them to the existing conditions. For example, a broadband provider specifies the infrastructure and processes for the roll-out of new network infrastructure - requirements of this kind must be uniformly taken into account by all teams at an early stage of development.
Our QA team works across teams: The team analyzes the customer's quality requirements and works with the developer teams to decide on rules and processes for their uniform implementation and monitoring. For this purpose, the team is in constant contact with the code maintainers of the individual teams and system testers as well as with the project management.
Concrete activities of our QA teams:
Quality agreements for tools and frameworks
In cooperation with the developer and infrastructure teams within the project, we draft and sharpen quality agreements for code in the programming languages used in the project (e.g. Go and Java), as well as for tools used (e.g. Docker and Kubernetes) and for development processes (GitFlow, processing of merge requests (MRs), test processes). The agreements include, for example:
> policies for the structure and formatting of the code
> policies for using libraries
> policies for logging system-internal processes
> name conventions for branches
> policies for merge requests in GitLab
> policies for allowed Docker Base Images
We take particular care to integrate agreements that have already been established in the individual project teams, and accompany their standardization and visible documentation.
Static code analysis (SCA)
In particular, our quality agreements also contain rules for the use of tools for static code analysis (linting, SAST, etc.) in the CI pipeline, so that potential violations of the quality agreements can be found and remedied directly by developers during a commit.
To extend and standardize the tools used in the project so far, we are working on the project-wide provision of SonarQube (https: / /www.sonarqube.org/). SonarQube offers static code analysis for many different languages on a uniform platform and clearly visualizes the analysis results. This makes it easier to evaluate the overall code quality for everyone involved in the project, from the developer to the product owner.
We plan to connect SonarQube to the GitLab instance used in the project, so that merge requests in GitLab are automatically decorated with the results of SonarQube analyses. This allows both developers and reviewers to quickly see which potential problems exist in new code and which have already been fixed.
The particular challenge when introducing SonarQube is to adapt the analysis rules used in SonarQube to project-specific requirements and, if necessary, to expand them appropriately. We design and iterate these adjustments in collaboration with the project teams.
Evaluate and support development activities automatically
In a large development project, many different teams have to coordinate their work with one another, for example the APIs of the individual microservices must be compatible with each other. At the same time, new versions of individual microservices are created at short intervals.
We help to coordinate these processes in a meaningful way by adding automatic scripts to the tools available in GitLab. For example, our scripts create a "GitLab weather report" that summarizes the project-relevant activities in GitLab for all project members (e.g. status of new release branches in relevant repositories). Additional scripts automatically create the base for release notes, check the compatibility of the microservices with one another by comparing the versions of the information model used, and analyze the dependencies used.
Regular quality review
In cooperation with the developer and infrastructure teams within the project, we draft and sharpen quality agreements for code in the programming languages used in the project (e.g. Go and Java), as well as for tools used (e.g. Docker and Kubernetes) and for development processes (GitFlow, processing of merge requests (MRs), test processes). The agreements include, for example:ment the results of the reviews as "technical debt" which, depending on the severity, must be removed for a current or future release.
+49 151 624 163 90
Marketing & Partnership
Director HR & Communications
+ 49 151 155 240 69