**Ayude a mejorar esta página** 

Para contribuir a esta guía del usuario, elija el enlace **Edit this page on GitHub** que se encuentra en el panel derecho de cada página.

# Uso de ApplicationSets
<a name="argocd-applicationsets"></a>

Los ApplicationSets generan varias aplicaciones a partir de plantillas, lo que le permite implementar la misma aplicación en varios clústeres, entornos o espacios de nombres con una sola definición de recursos.

## Requisitos previos
<a name="_prerequisites"></a>
+ Un clúster de EKS con la capacidad de Argo CD creada
+ Acceso al repositorio configurado (consulte [Configuración del acceso al repositorio](argocd-configure-repositories.md))
+  `kubectl` configurado para comunicarse con el clúster

**nota**  
No se requieren varios clústeres de destino para ApplicationSets. Puede utilizar generadores distintos del generador de clústeres (como los generadores de lista, git o matriz) para implementar aplicaciones sin clústeres remotos.

## Cómo funcionan los ApplicationSets
<a name="_how_applicationsets_work"></a>

Los ApplicationSets utilizan generadores para producir parámetros y, a continuación, aplicarlos a una plantilla de aplicación. Cada conjunto de parámetros generados crea una aplicación.

Generadores comunes para implementaciones de EKS:
+  **Generador de listas**: defina de forma explícita los clústeres y los parámetros para cada entorno.
+  **Generador de clústeres**: implemente automáticamente en todos los clústeres registrados.
+  **Generador de Git**: genere aplicaciones a partir de la estructura del repositorio.
+  **Generador de matrices**: combine generadores para implementaciones multidimensionales.
+  **Generador de combinación**: combina parámetros de varios generadores

Para obtener una referencia completa sobre generadores, consulte la [documentación de ApplicationSet](https://argo-cd.readthedocs.io/en/stable/user-guide/application-set/).

## Generador de listas
<a name="_list_generator"></a>

Implemente en varios clústeres con una configuración explícita:

```
apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: guestbook-all-clusters
  namespace: argocd
spec:
  generators:
  - list:
      elements:
      - environment: dev
        replicas: "2"
      - environment: staging
        replicas: "3"
      - environment: prod
        replicas: "5"
  template:
    metadata:
      name: 'guestbook-{{environment}}'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/guestbook
        targetRevision: HEAD
        path: 'overlays/{{environment}}'
      destination:
        name: '{{environment}}-cluster'
        namespace: guestbook
      syncPolicy:
        automated:
          prune: true
          selfHeal: true
```

**nota**  
Utilice `destination.name` con nombres de clústeres para mejorar la legibilidad. El campo `destination.server` también funciona con los ARN de clústeres de EKS si es necesario.

Esto crea tres aplicaciones: `guestbook-dev`, `guestbook-staging` y `guestbook-prod`.

## Generador de clústeres
<a name="_cluster_generator"></a>

Implemente automáticamente en todos los clústeres registrados:

```
apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: cluster-addons
  namespace: argocd
spec:
  generators:
  - clusters: {}
  template:
    metadata:
      name: '{{name}}-addons'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/cluster-addons
        targetRevision: HEAD
        path: addons
      destination:
        server: '{{server}}'
        namespace: kube-system
      syncPolicy:
        automated:
          prune: true
          selfHeal: true
```

Esto crea automáticamente una aplicación para cada clúster registrado.

 **Filtrar clústeres**:

Utilice `matchLabels` para incluir clústeres específicos o `matchExpressions` para excluir clústeres:

```
spec:
  generators:
  - clusters:
      selector:
        matchLabels:
          environment: production
        matchExpressions:
        - key: skip-appset
          operator: DoesNotExist
```

## Generadores de Git
<a name="_git_generators"></a>

Los generadores de Git crean aplicaciones basadas en la estructura del repositorio:
+  **Generador de directorios**: implemente cada directorio como una aplicación independiente (útil para microservicios).
+  **Generador de archivos**: genere aplicaciones a partir de archivos de parámetros (útil para implementaciones con varios inquilinos).

 **Ejemplo: implementación de microservicios** 

```
apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: microservices
  namespace: argocd
spec:
  generators:
  - git:
      repoURL: https://github.com/example/microservices
      revision: HEAD
      directories:
      - path: services/*
  template:
    metadata:
      name: '{{path.basename}}'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/microservices
        targetRevision: HEAD
        path: '{{path}}'
      destination:
        name: my-cluster
        namespace: '{{path.basename}}'
      syncPolicy:
        automated:
          prune: true
          selfHeal: true
        syncOptions:
        - CreateNamespace=true
```

Para obtener detalles sobre los generadores de Git y la configuración basada en archivos, consulte [Git Generator](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Generators-Git/) en la documentación de Argo CD.

## Generador de matrices
<a name="_matrix_generator"></a>

Combine varios generadores para implementarlos en múltiples dimensiones (entornos × clústeres):

```
apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: multi-env-multi-cluster
  namespace: argocd
spec:
  generators:
  - matrix:
      generators:
      - list:
          elements:
          - environment: dev
          - environment: staging
          - environment: prod
      - clusters:
          selector:
            matchLabels:
              region: us-west-2
  template:
    metadata:
      name: 'app-{{environment}}-{{name}}'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/app
        targetRevision: HEAD
        path: 'overlays/{{environment}}'
      destination:
        name: '{{name}}'
        namespace: 'app-{{environment}}'
```

Para obtener más información sobre cómo combinar generadores, consulte [Matrix Generator](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Generators-Matrix/) en la documentación de Argo CD.

## Implementación multirregional
<a name="_multi_region_deployment"></a>

Implemente en clústeres de varias regiones:

```
apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: global-app
  namespace: argocd
spec:
  generators:
  - list:
      elements:
      - clusterName: prod-us-west
        region: us-west-2
      - clusterName: prod-us-east
        region: us-east-1
      - clusterName: prod-eu-west
        region: eu-west-1
  template:
    metadata:
      name: 'app-{{region}}'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/app
        targetRevision: HEAD
        path: kubernetes
        helm:
          parameters:
          - name: region
            value: '{{region}}'
      destination:
        name: '{{clusterName}}'
        namespace: app
      syncPolicy:
        automated:
          prune: true
          selfHeal: true
```

## Administración de ApplicationSets
<a name="_manage_applicationsets"></a>

 **Vea los ApplicationSets y las aplicaciones generadas**:

```
kubectl get applicationsets -n argocd
kubectl get applications -n argocd -l argocd.argoproj.io/application-set-name=<applicationset-name>
```

 **Actualice un ApplicationSet**:

Modifique la especificación de ApplicationSet y vuelva a aplicarla. Argo CD actualiza automáticamente todas las aplicaciones generadas:

```
kubectl apply -f applicationset.yaml
```

 **Elimine un ApplicationSet**:

```
kubectl delete applicationset <name> -n argocd
```

**aviso**  
Al eliminar un conjunto de aplicaciones, se eliminan todas las aplicaciones generadas. Si esas aplicaciones tienen `prune: true`, sus recursos también se eliminarán de los clústeres de destino.  
Para conservar los recursos implementados al eliminar un ApplicationSet, establezca `.syncPolicy.preserveResourcesOnDeletion` en `true` en la especificación del ApplicationSet. Para obtener más información, consulte [Eliminación de recursos y limpieza de aplicaciones](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Application-Deletion/) en la documentación de Argo CD.

**importante**  
La característica ApplicationSets de Argo CD tiene consideraciones de seguridad que debe tener en cuenta antes de utilizar ApplicationSets. Para obtener más información, consulte [Seguridad de ApplicationSet](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Security/) en la documentación de Argo CD.

## Recursos adicionales
<a name="_additional_resources"></a>
+  [Uso de proyectos de Argo CD](argocd-projects.md): organización de ApplicationSets con proyectos
+  [Creación de aplicaciones](argocd-create-application.md): descripción de la configuración de la aplicación
+  [Documentación de ApplicationSet](https://argo-cd.readthedocs.io/en/stable/user-guide/application-set/): patrones y referencia completos sobre generadores
+  [Referencia sobre generadores](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Generators/): especificaciones detalladas sobre los generadores