Garbage Collect

    In garbage-collect policy, there are two major capabilities you can use.

    Suppose you want to keep the resources created by the old version of the application. Use the garbage-collect policy and enable the option .

    1. create app

    Check the status:

    1. vela status first-vela-app --tree

    expected output

    1. CLUSTER       NAMESPACE     RESOURCE                  STATUS
    2. local     ─── default   ─┬─ Service/express-server    updated
    3.                          ├─ Deployment/express-server updated
    4.                          └─ Ingress/express-server    updated
    1. update the app
    1. cat <<EOF | vela up -f -
    2. apiVersion: core.oam.dev/v1beta1
    3. kind: Application
    4. metadata:
    5.   name: first-vela-app
    6. spec:
    7.   components:
    8.     - name: express-server-1
    9.       type: webservice
    10.       properties:
    11.         image: oamdev/hello-world
    12.         port: 8000
    13.       traits:
    14.         - type: gateway
    15.           properties:
    16.             class: traefik
    17.             domain: 47.251.8.82.nip.io
    18.             http:
    19.               "/": 8000
    20.   policies:
    21.     - name: keep-legacy-resource
    22.       type: garbage-collect
    23.       properties:
    24.         keepLegacyResource: true
    25. EOF

    expected output

    1. CLUSTER       NAMESPACE     RESOURCE                    STATUS
    2. local     ─── default   ─┬─ Service/express-server      outdated
    3.                          ├─ Service/express-server-1    updated
    4.                          ├─ Deployment/express-server   outdated
    5.                          ├─ Deployment/express-server-1 updated
    6.                          ├─ Ingress/express-server      outdated
    7.                          └─ Ingress/express-server-1    updated

    You can see the legacy resources are reserved but the status is outdated, it will not be synced by periodically reconciliation.

    1. delete the app
    1. $ vela delete first-vela-app

    Persist partial resources

    You can also persist part of the resources, which skips the normal garbage-collect process when the application is updated.

    1. cat <<EOF | vela up -f -
    2. apiVersion: core.oam.dev/v1beta1
    3. metadata:
    5. spec:
    6.   components:
    7.     - name: demo-gc
    8.       type: webservice
    9.       properties:
    10.         image: oamdev/hello-world
    11.       traits:
    12.         - type: expose
    13.           properties:
    14.             port: [8000]
    15.   policies:
    16.     - name: garbage-collect
    17.       type: garbage-collect
    18.       properties:
    19.         rules:
    20.           - selector:
    21.               traitTypes:
    22.                 - expose
    23.             strategy: onAppDelete
    24. EOF

    You can find deployment and service created.

    If you upgrade the application and use a different component, you will find the old versioned deployment is deleted but the service is kept.

    1. cat <<EOF | vela up -f -
    2. apiVersion: core.oam.dev/v1beta1
    3. kind: Application
    4. metadata:
    5.   name: garbage-collect-app
    6. spec:
    7.   components:
    8.     - name: hello-world-new
    9.       type: webservice
    10.       properties:
    11.         image: oamdev/hello-world
    12.       traits:
    13.         - type: expose
    14.           properties:
    15.             port: [8000]
    16.   policies:
    17.     - name: garbage-collect
    18.       type: garbage-collect
    19.       properties:
    20.         rules:
    21.           - selector:
    22.               traitTypes:
    23.                 - expose
    24. EOF
    26. $ kubectl get deployment
    27. NAME              READY   UP-TO-DATE   AVAILABLE   AGE
    28. hello-world-new   1/1     1            1           10s
    29. $ kubectl get service   
    30. NAME              TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
    31. hello-world       ClusterIP   10.96.160.208   <none>        8000/TCP   5m56s
    32. hello-world-new   ClusterIP   10.96.20.4      <none>        8000/TCP   13s

    If you want to deploy job-like components, in which cases the resources in the component are not expected to be recycled even after the application is deleted, you can use the component type selector and set strategy to never as follows.

    1. apiVersion: core.oam.dev/v1beta1
    2. kind: Application
    3. metadata:
    4.   name: garbage-collect-app
    5. spec:
    6.   components:
    7.     - name: hello-world-new
    8.       type: job-like-component
    9.   policies:
    10.     - name: garbage-collect
    11.       type: garbage-collect
    12.       properties:
    13.         rules:
    14.           - selector:
    15.               componentTypes:
    16.                 - webservice
    17.             strategy: never

    An alternative selector for the component resources is the component name selector.

    1. apiVersion: core.oam.dev/v1beta1
    2. kind: Application
    3. metadata:
    4.   name: create-ns-app
    5. spec:
    6.   components:
    7.     - name: example-addon-namespace
    8.       type: k8s-objects
    9.       properties:
    10.         objects:
    11.           - apiVersion: v1
    12.             kind: Namespace
    13.   policies:
    14.     - name: garbage-collect
    15.       type: garbage-collect
    16.       properties:
    17.         rules:
    18.           - selector:
    19.               componentNames: