Vous pouvez utiliser les ressources et les paramètres de mise en réseau, de sécurité et d'équilibrage de charge dans les conceptions et les déploiements de modèles de cloud.

Pour obtenir un résumé des options de code de conception de modèle de cloud, consultez Schéma de type de ressource de vRealize Automation.

Pour obtenir des informations complémentaires, consultez :

Ces exemples illustrent les ressources de réseau, de sécurité et d’équilibrage de charge dans les conceptions de modèle de cloud de base.

Réseaux

Scénario de ressources Exemple de code de conception de modèle de cloud
Machine vSphere sur laquelle plusieurs cartes réseau sont connectées à des réseaux vSphere et NSX avec attribution d'adresses IP DHCP

 
resources:
  demo-machine:
    type: Cloud.vSphere.Machine
    properties:
      image: ubuntu
      flavor: small
      networks:
        - network: ${resource["demo-vSphere-Network"].id}
          deviceIndex: 0
        - network: ${resource["demo-NSX-Network"].id}
          deviceIndex: 1
  demo-vSphere-Network:
    type: Cloud.vSphere.Network
    properties:
      networkType: existing
  demo-NSX-Network:
    type: Cloud.NSX.Network
    properties:
      networkType: outbound
Réseau privé NSX utilisant la propriété vlanIds pour spécifier une baie de 3 VLAN : 123, 456 et 7 
formatVersion: 1
inputs: {}
resources:
  Cloud_Machine_1:
    type: Cloud.Machine
    properties:
      image: test
      flavor: test
      networks:
       - network: '${resource.Cloud_NSX_Network_1.id}'  
  Cloud_NSX_Network_1:
    type: Cloud.NSX.Network
    properties:
      networkType: private
      vlanIds:
         - 123 
         - 456
         - 7
Ajoutez un réseau privé avec une adresse IP statique pour un déploiement de machine virtuelle Azure 
formatVersion: 1
inputs: {}
resources:
  Cloud_Azure_Machine_1:
    type: Cloud.Machine
    properties:
      image: photon
      flavor: Standard_B1ls
      networks:
        - network: '${resource.Cloud_Network_1.id}'
          assignment: static
          address: 10.0.0.45
          assignPublicIpAddress: false
  Cloud_Network_1:
    type: Cloud.Network
    properties:
      networkType: existing

Vous pouvez utiliser une attribution d'adresse IP statique avec vRealize Automation IPAM (interne comme fournie avec vRealize Automation ou externe basée sur le SDK IPAM vRealize Automation comme pour l'un des plug-ins Infloblox disponibles dans VMware Marketplace). Les autres utilisations de assignment: static ne sont pas prises en charge, comme décrit dans la section Mises en garde de En savoir plus sur les ressources réseau dans les modèles de cloud vRealize Automation. 

resources:
  demo_vm:
    type: Cloud.vSphere.Machine
    properties:
      image: 'photon'
      cpuCount: 1
      totalMemoryMB: 1024
      networks:
        - network: ${resource.demo_nw.id}
          assignment: static
  demo_nw:
    type: Cloud.vSphere.Network
    properties:
      networkType: existing
Ajoutez ou modifiez des règles de transfert de port NAT et DNAT dans une ressource Cloud.NSX.NAT pour un déploiement existant. 
resources:
  gw:
    type: Cloud.NSX.Gateway
    properties:
      networks:
        - ${resource.akout.id}
  nat:
    type: Cloud.NSX.Nat
    properties:
      networks:
        - ${resource.akout.id}
      natRules:
        - translatedInstance: ${resource.centos.networks[0].id}
          index: 0
          protocol: TCP
          kind: NAT44
          type: DNAT
          sourceIPs: any
          sourcePorts: 80
          translatedPorts: 8080
          destinationPorts: 8080
          description: edit
        - translatedInstance: ${resource.centos.networks[0].id}
          index: 1
          protocol: TCP
          kind: NAT44
          type: DNAT
          sourceIPs: any
          sourcePorts: 90
          translatedPorts: 9090
          destinationPorts: 9090
          description: add
      gateway: ${resource.gw.id}
  centos:
    type: Cloud.vSphere.Machine
    properties:
      image: WebTinyCentOS65x86
      flavor: small
      customizationSpec: Linux
      networks:
        - network: ${resource.akout.id}
          assignment: static
  akout:
    type: Cloud.NSX.Network
    properties:
      networkType: outbound
      constraints:
        - tag: nsxt-nat-1-M2

Une machine de cloud public utilise une adresse IP interne au lieu d'une adresse IP publique Cet exemple utilise un ID réseau spécifique.

Remarque : l'option network: est utilisée dans le paramètre networks: pour spécifier un ID réseau cible. L'option name: du paramètre networks: a été désapprouvée et ne doit pas être utilisée.

 
resources:
  wf_proxy:
    type: Cloud.Machine
    properties:
      image: ubuntu 16.04
      flavor: small
      constraints:
        - tag: 'platform:vsphere'
      networks:
        - network: '${resource.wf_net.id}'
          assignPublicIpAddress: false

Réseau routé à l'aide du type de ressource réseau NSX. 

Cloud_NSX_Network_1:
    type: Cloud.NSX.Network
    properties:
      networkType: routed
Ajoutez une balise à une ressource de carte réseau de machine dans le modèle de cloud. 
formatVersion: 1
inputs: {}
resources:
 Cloud_Machine_1:
 type: Cloud.vSphere.Machine
 properties:
  flavor: small
  image: ubuntu
  networks:
     - name: '${resource.Cloud_Network_1.name}'
     deviceIndex: 0
     tags: 
      - key: 'nic0'
        value: null
      - key: internal
        value: true
     - name: '${resource.Cloud_Network_2.name}'
     deviceIndex: 1
     tags: 
      - key: 'nic1'
        value: null
      - key: internal
        value: false

Balisez les commutateurs logiques NSX-T pour un réseau sortant.

Le balisage est pris en charge pour NSX-T et VMware Cloud on AWS.

Pour plus d'informations sur ce scénario, reportez-vous à l'article de blog de la communauté Creating Tags in NSX with Cloud Assembly (Création de balises dans NSX avec Cloud Assembly).

 
Cloud_NSX_Network_1:
    type: Cloud.NSX.Network
    properties:
      networkType: outbound
      tags: 
        - key: app
          value: opencart

Groupes de sécurité

Scénario de ressources Exemple de code de conception de modèle de cloud

Groupe de sécurité existant avec une balise de contrainte appliquée à la carte réseau d'une machine.

Pour utiliser un groupe de sécurité existant, entrez existant pour la propriété securityGroupType .

Vous pouvez attribuer des balises à une ressource de Cloud.SecurityGroup pour allouer des groupes de sécurité existants en utilisant des contraintes de balise. Les groupes de sécurité qui ne contiennent aucune balise ne peuvent pas être utilisés dans la conception du modèle de cloud.

Les balises de contrainte doivent être définies pour des ressources de groupes de sécurité securityGroupType: existing. Ces contraintes doivent correspondre aux balises définies sur les groupes de sécurité existants. Les balises de contrainte ne peuvent pas être définies pour les ressources de groupe de sécurité securityGroupType: new. 

formatVersion: 1
inputs: {}
resources:
  allowSsh_sg:
    type: Cloud.SecurityGroup
    properties:
      securityGroupType: existing
      constraints:
        - tag: allowSsh
  compute:
    type: Cloud.Machine
    properties:
      image: centos
      flavor: small
      networks:
        - network: '${resource.prod-net.id}'
          securityGroups:
            - '${resource.allowSsh_sg.id}'
  prod-net:
    type: Cloud.Network
    properties:
      networkType: existing

Groupe de sécurité à la demande incluant deux règles de pare-feu illustrant les options d'accès Allow et Deny. 

resources:
  Cloud_SecurityGroup_1:
    type: Cloud.SecurityGroup
    properties:
      securityGroupType: new
      rules:
        - ports: 5000
          source: 'fc00:10:000:000:000:56ff:fe89:48b4'
          access: Allow
          direction: inbound
          name: allow_5000
          protocol: TCP
        - ports: 7000
          source: 'fc00:10:000:000:000:56ff:fe89:48b4'
          access: Deny
          direction: inbound
          name: deny_7000
          protocol: TCP
  Cloud_vSphere_Machine_1:
    type: Cloud.vSphere.Machine
    properties:
      image: photon
      cpuCount: 1
      totalMemoryMB: 256
      networks:
        - network: '${resource.Cloud_Network_1.id}'
          assignIPv6Address: true
          assignment: static
          securityGroups:
            - '${resource.Cloud_SecurityGroup_1.id}'
  Cloud_Network_1:
    type: Cloud.Network
    properties:
      networkType: existing
Modèle de cloud complexe incluant 2 groupes de sécurité, notamment :
  • 1 groupe de sécurité existant
  • 1 groupe de sécurité à la demande incluant plusieurs exemples de règles de pare-feu
  • 1 machine vSphere
  • 1 réseau existant

Cet exemple illustre différentes combinaisons de protocole et de ports, de services, de CIDR IP en tant que source et destination, de plages d'adresses IP en tant que source ou destination, et les options pour tous, IPv6 et (::/0).

Pour les cartes réseau de machine, vous pouvez spécifier le réseau connecté, ainsi que le ou les groupes de sécurité. Vous pouvez également spécifier l'index de la carte réseau ou une adresse IP.

 
formatVersion: 1
inputs: {}
resources:
  DEMO_ESG : existing security group - security group 1)
    type: Cloud.SecurityGroup
    properties:
      constraints:
        - tag: BlockAll
      securityGroupType: existing (designation of existing for security group 1) 
  DEMO_ODSG: (on-demand security group - security group 2))
    type: Cloud.SecurityGroup
    properties:
      rules: (multiple firewall rules in this section)
        - name: IN-ANY (rule 1)
          source: any
          service: any
          direction: inbound
          access: Deny
        - name: IN-SSH (rule 2)
          source: any
          service: SSH
          direction: inbound
          access: Allow
        - name: IN-SSH-IP (rule 3)
          source: 33.33.33.1-33.33.33.250
          protocol: TCP
          ports: 223
          direction: inbound
          access: Allow
        - name: IPv-6-ANY-SOURCE (rule 4)
          source: '::/0'
          protocol: TCP
          ports: 223
          direction: inbound
          access: Allow
        - name: IN-SSH-IP (rule 5)
          source: 44.44.44.1/24
          protocol: UDP
          ports: 22-25
          direction: inbound
          access: Allow
        - name: IN-EXISTING-SG (rule 6)
          source: '${resource["DEMO_ESG"].id}'
          protocol: ICMPv6
          direction: inbound
          access: Allow
        - name: OUT-ANY (rule 7)
          destination: any
          service: any
          direction: outbound
          access: Deny
        - name: OUT-TCP-IPv6 (rule 8)
          destination: '2001:0db8:85a3::8a2e:0370:7334/64'
          protocol: TCP
          ports: 22
          direction: outbound
          access: Allow
        - name: IPv6-ANY-DESTINATION (rule 9)
          destination: '::/0'
          protocol: UDP
          ports: 23
          direction: outbound
          access: Allow
        - name: OUT-UDP-SERVICE (rule 10)
          destination: any
          service: NTP
          direction: outbound
          access: Allow
      securityGroupType: new (designation of on-demand for security group 2)
  DEMO_VC_MACHINE: (machine resource)
    type: Cloud.vSphere.Machine 
    properties:
      image: PHOTON
      cpuCount: 1
      totalMemoryMB: 1024
      networks: (Machine network NICs)
        - network: '${resource.DEMO_NW.id}'
          securityGroups:
            - '${resource.DEMO_ODSG.id}'
            - '${resource.DEMO_ESG.id}'
  DEMO_NETWORK: (network resource)
    type: Cloud.vSphere.Network
    properties:
      networkType: existing
      constraints:
        - tag: nsx62

Équilibrages de charge

Scénario de ressources Exemple de code de conception de modèle de cloud

Spécifiez un niveau de journalisation, un algorithme et une taille d'équilibrage de charge.

Exemple d'équilibrage de charge NSX illustrant l'utilisation du niveau, de l'algorithme et de la taille de journalisation :

resources:
  Cloud_LoadBalancer_1:
    type: Cloud.NSX.LoadBalancer
    properties:
      name: myapp-lb
      network: '${appnet-public.name}'
      instances: '${wordpress.id}'
      routes:
       - protocol: HTTP port: '80'
         loggingLevel: CRITICAL 
         algorithm: LEAST_CONNECTION
         type: MEDIUM

Associez un équilibrage de charge à une machine nommée ou à une carte réseau de machine nommée. Vous pouvez spécifier machine ID ou machine network ID pour ajouter la machine au pool d'équilibrage de charge. La propriété Instances prend en charge à la fois les machines (machine by ID) et les cartes réseau (machine by network ID).

Dans le premier exemple, le déploiement utilise le paramètre machine by ID pour équilibrer la charge de la machine lorsqu'elle est déployée sur un réseau.

Dans le second exemple, le déploiement utilise le paramètre machine by network ID pour équilibrer la charge de la machine uniquement lorsque la machine est déployée sur la carte réseau de la machine nommée.

Le troisième exemple montre les deux paramètres utilisés dans la même option instances.
Vous pouvez utiliser la propriété instances pour définir un ID de machine ou un ID réseau de machine :
  • ID de machine
    Cloud_LoadBalancer_1:
 type: Cloud.LoadBalancer
 properties:
   network: '${resource.Cloud_Network_1.id}'
   instances: '${resource.Cloud_Machine_1.id}'
  • ID réseau de machine
    Cloud_LoadBalancer_1:
 type: Cloud.LoadBalancer
 properties:
   network: '${resource.Cloud_Network_1.id}'
   instances: '${resource.Cloud_Machine_1.networks[0].id}'
  • Une machine spécifiée pour l'inclusion de l'équilibrage de charge et une autre carte réseau de machine spécifiée pour l'inclusion de l'équilibrage de charge :
    instances:
  - resource.Cloud_Machine_1.id
  - resource.Cloud_Machine_2.networks[2].id
Ajoutez des paramètres de contrôle de santé à un équilibrage de charge NSX. Les options supplémentaires incluent httpMethod, requestBody et responseBody. 
myapp-lb:
  type: Cloud.NSX.LoadBalancer
  properties:
    name: myapp-lb
    network: '${appnet-public.name}'
    instances: '${wordpress.id}'
    routes:
     - protocol: HTTP
       port: '80'
       algorithm: ROUND_ROBIN
       instanceProtocol: HTTP
       instancePort: '80'
       healthCheckConfiguration:
         protocol: HTTP
         port: '80'
         urlPath: /mywordpresssite/wp-admin/install.php
         intervalSeconds: 60
         timeoutSeconds: 10
         unhealthyThreshold: 10
         healthyThreshold: 2
       connectionLimit: '50'
       connectionRateLimit: '50'
       maxConnections: '500'
       minConnections: ''
     internetFacing: true{code}

Réseau à la demande avec un équilibrage de charge à un bras. 

inputs: {}
resources:
  mp-existing:
    type: Cloud.Network
    properties:
      name: mp-existing
      networkType: existing
  mp-wordpress:
    type: Cloud.vSphere.Machine
    properties:
      name: wordpress
      count: 2
      flavor: small
      image: tiny
      customizationSpec: Linux
      networks:
        - network: '${resource["mp-private"].id}'
  mp-private:
    type: Cloud.NSX.Network
    properties:
      name: mp-private
      networkType: private
      constraints:
        - tag: nsxt
  mp-wordpress-lb:
    type: Cloud.LoadBalancer
    properties:
      name: wordpress-lb
      internetFacing: false
      network: '${resource.mp-existing.id}'
      instances: '${resource["mp-wordpress"].id}'
      routes:
        - protocol: HTTP
          port: '80'
          instanceProtocol: HTTP
          instancePort: '80'
          healthCheckConfiguration:
            protocol: HTTP
            port: '80'
            urlPath: /index.pl
            intervalSeconds: 60
            timeoutSeconds: 30
            unhealthyThreshold: 5
            healthyThreshold: 2

Réseau existant avec un équilibrage de charge.

 
formatVersion: 1
inputs:
  count:
    type: integer
    default: 1
resources:
  ubuntu-vm:
    type: Cloud.Machine
    properties:
      name: ubuntu
      flavor: small
      image: tiny
      count: '${input.count}'
      networks:
        - network: '${resource.Cloud_NSX_Network_1.id}'
  Provider_LoadBalancer_1:
    type: Cloud.LoadBalancer
    properties:
      name: OC-LB
      routes:
        - protocol: HTTP
          port: '80'
          instanceProtocol: HTTP
          instancePort: '80'
          healthCheckConfiguration:
            protocol: HTTP
            port: '80'
            urlPath: /index.html
            intervalSeconds: 60
            timeoutSeconds: 5
            unhealthyThreshold: 5
            healthyThreshold: 2
      network: '${resource.Cloud_NSX_Network_1.id}'
      internetFacing: false
      instances: '${resource["ubuntu-vm"].id}'
  Cloud_NSX_Network_1:
    type: Cloud.NSX.Network
    properties:
      networkType: existing
      constraints:
        - tag: nsxt24prod

En savoir plus

Des informations connexes sont disponibles dans les blogs VMware suivants :