Multi-tenant repo: why the tenant deployment GitRepository has to be definied twice?

bauger

I noticed that the facebooc-deploy tenant Git repository is declared twice:

• [flux-fleet]/projects/base/facebooc/facebooc-deploy-gitrepository.yaml creating a facebooc-deploy kubernetes object and;
• [tenant-repo/facebooc-deploy]/flux/base/facebook-repository.yaml creating a facebooc kubernetes object.

I could change the name of the GitRepository CRD declared in the tenant Git repository to match the name of the one declared in the Flux Fleet Git repository and everything works fine. However, when I delete the second declaration (the one in the tenant repository) as it is pointing to its own parent repository and its equivalent has already been declared in the flux infrastructure, the kustomization reconciliation fails. Obviously the GitRepository CRD in the Git tenant deploy repository is required. I do not understand why?

Can you help me to figure out the purpose of this second GitRepository declaration? I do not see anything in the flux documentation that can explain what is the underlying mechanism.

Thanks,

Béatrice

bauger

Also, during my tests, I used the same namespace (facebooc) on every CRD on both the flux fleet Git repository manifests and the tenant deployment Git repository manifests.

bauger

My apologies, I forgot to update the kustomization manifest in the Git tenant deployment repository accordingly.

I confirm that the everything works without the 2nd GitRepository (the one in the Git tenant deployment repository).

Thanks

luisviveropena

Hi @bauger , thanks for confirming that the lab worked for you.

Regards,
Luis.

gouravshah

@bauger I had designed the repository structure based on this resource available https://github.com/fluxcd/flux2-multi-tenancy. At the time of authoring this course, there was not a lot of information I could find from the official documentation (which may have changed now). This is more of a design pattern and not the standard/only way of achieving multi tenancy. I am sure this could be approached in different ways as well.

I would review the code and update this thread if there is need for the tenant repo CRD.

bauger

@luisviveropena and @gouravshah,
thanks for your answers.

Unfortunately, at this point I am not able to get a multi-tenant FluxCD infrastructure working with the instavote deployment. I focused on the https://github.com/lfs269/facebooc-deploy.git and the https://github.com/lfs269/flux-fleet.git, as for myself too, the FluxCD documentation is confusing: the https://github.com/fluxcd/flux2-multi-tenancy point to itself rather than a real tenant deployment repository and the FluxCD documentation does not explain neither if there is some expected repository architecture to get flux controllers working. It let me confused because I cannot follow a tool mechanism logic to understand how to deploy, neither I can follow a design pattern logic. For example, is 'app' refering to microservice? And what could be the setting implications in terms of repository structure/k8s manifest declarations? Also, reading through https://fluxcd.io/docs/flux-e2e I could not see how to combine it with https://fluxcd.io/docs/guides/repository-structure...

From here, I will follow the last section (with Flagger) without applying in to the instavote case. if I could, I will try with the facebooc-deploy use case.

Thanks,

Béatrice

gouravshah

@bauger I have reviewed the code based on your earlier comments. There is a reason why the same Git repo is referenced in two places. Here are my comments

[flux-fleet]/projects/base/facebooc/facebooc-deploy-gitrepository.yaml
With the context of this if you observe the code in ... projects/staging/facebooc-deploy-kustomization.yaml

---
apiVersion: kustomize.toolkit.fluxcd.io/v1beta1
kind: Kustomization
metadata:
  name: facebooc-deploy
  namespace: facebooc
spec:
  path: ./flux/staging

You would notice that its calling for kustomization in flux/staging path. This is for Tenant/Project onboarding.

Consequently , with the context of

[tenant-repo/facebooc-deploy]/flux/base/facebook-repository.yaml

this is in reference to facebooc-deploy/flux/staging/facebooc-kustomization.yaml

which is then referring to the same Git repo, but calling code from a different path as follows

---
apiVersion: kustomize.toolkit.fluxcd.io/v1beta1
kind: Kustomization
metadata:
  name: facebooc
  namespace: flux-system
spec:
  path: ./kustomize/facebooc/staging

this is where the actual application would get deployed.

So in summary, the same repo contains both project/tenant onboarding code + application deployment code. This is just a design pattern. You could also maintain the application deployment code somewhere else (e.g. in the application code repo). I hope this helps. If you have follow up questions, would be glad to help.

bauger

@gouravshah

Thanks for your answer. At this point, I still have the same feeling that from a learning perspective this design pattern is confusing me for two reasons:

• The mix of applications and microservices deployments in the same git repository does not help to clarify what should be a good practice to deploy and maintain code; as it is, this design pattern seems to be at the transitional stage from monolith to microservices. I can understand to get a git repository (deployment and/or development) by team, or a git repository by application and one by microservice. Also, understanding developer, devops and sysadmin accountability with such infrastructure matters for me.
• Understanding the transition from single-tenant to multi-tenant meant for me to get if fluxCD imposes a specific folder structure. Following a very simple example like with this post (part 1 and part 2) helped me to realize that fluxCD is flexible and I would not have to follow a strict structure in the git repositories (the tenant one and the flux-fleet one).

Thanks

gouravshah

@bauger

You are right when you say FluxCD does not impose any specific structure and offers flexibility as to how you design your multi tenant setup. That is also the reason for confusion as there are different design patterns which have evolved to address it with different goals.

Comparing atleast two of those, I arrived at the design which I have proposed and followed as part of this course.

The choice would also come down to who is responsible for what in a organisation. For example, some times its the developers who would maintain both, the application code, along with deployment code. In other orgs, deployment code is the responsibility of a SRE/Devops Engineering Teams.

My suggestion is

1. you come up with the best practices and ownership patterns that you would like to follow.
2. Design the repositories accordingly
3. Make it a internal mandate and have it followed for all the projects that you deploy

Since FluxCD is flexible, you could use that as an advantage and mould it the way you see fit.