anyscale 0.26.68__py3-none-any.whl → 0.26.70__py3-none-any.whl

anyscale/controllers/cloud_controller.py

@@ -1746,7 +1746,7 @@ class CloudController(BaseController):
         spec_file: str,
         skip_verification: bool = False,
         yes: bool = False,
-    ):
+    ) -> str:
         cloud_id, _ = get_cloud_id_and_name(
             self.api_client, cloud_id=cloud_id, cloud_name=cloud
         )
@@ -1797,16 +1797,21 @@ class CloudController(BaseController):
 
         # Add the resource.
         try:
-            self.api_client.add_cloud_resource_api_v2_clouds_cloud_id_add_resource_put(
+            response = self.api_client.add_cloud_resource_api_v2_clouds_cloud_id_add_resource_put(
                 cloud_id=cloud_id, cloud_deployment=new_deployment,
             )
         except Exception as e:  # noqa: BLE001
             raise ClickException(f"Failed to add cloud resource: {e}")
 
+        # Extract cloud_resource_id from the response
+        cloud_resource_id = response.result.cloud_resource_id
+
         self.log.info(
             f"Successfully created cloud resource{' ' + (new_deployment.name or '')} in cloud {cloud or cloud_id}!"
         )
 
+        return cloud_resource_id
+
     def update_cloud_resources(  # noqa: PLR0912, C901
         self,
         cloud_name: Optional[str],
@@ -1828,6 +1833,14 @@ class CloudController(BaseController):
 
         spec = yaml.safe_load(path.read_text())
 
+        # Normalize spec to a list
+        if isinstance(spec, dict):
+            spec = [spec]
+        elif not isinstance(spec, list):
+            raise ClickException(
+                "Invalid cloud resources file format. Must contain either a single CloudResource or a list of CloudResources."
+            )
+
         # Get the existing spec.
         existing_resources = self.get_cloud_resources(cloud_id=cloud_id)
 
@@ -4197,9 +4210,10 @@ class CloudController(BaseController):
             f"  --set-string global.cloudProvider={provider}",
         ]
 
-        # Add region for most providers (not for generic)
-        if region and provider != "generic":
-            command_parts.append(f"  --set-string global.region={region}")
+        # Add region only for AWS (using global.aws.region)
+        # Region field is deprecated for other providers
+        if region and provider == "aws":
+            command_parts.append(f"  --set-string global.aws.region={region}")
 
         # Add provider-specific parameters
         if provider == "gcp" and operator_iam_identity:

anyscale/controllers/kubernetes_verifier.py

@@ -12,6 +12,7 @@ Handles verification of Kubernetes-based cloud deployments including:
 
 from contextlib import contextmanager, suppress
 from dataclasses import dataclass
+from enum import Enum
 import json
 import os
 import shutil
@@ -90,8 +91,19 @@ KUBECTL_COMMON_PATHS = [
 # Status and result strings
 PASSED_STATUS = "PASSED"
 FAILED_STATUS = "FAILED"
+SKIPPED_STATUS = "SKIPPED"
 RUNNING_STATUS = "Running"
 
+
+# Verification status enum
+class VerificationStatus(Enum):
+    """Status of a verification check."""
+
+    PASSED = "PASSED"
+    FAILED = "FAILED"
+    SKIPPED = "SKIPPED"
+
+
 # Verification component names (for consistent reporting)
 class VerificationComponents:
     OPERATOR_POD_INSTALLED = "Operator Pod Installed"
@@ -206,15 +218,15 @@ class ResourceNotFoundError(KubernetesVerificationError):
 class VerificationResults:
     """Tracks the results of all verification steps."""
 
-    operator_pod_installed: bool = False
-    operator_health: bool = False
-    operator_identity: bool = False
-    file_storage: bool = False
-    gateway_support: bool = False
-    nginx_ingress: bool = False
+    operator_pod_installed: VerificationStatus = VerificationStatus.FAILED
+    operator_health: VerificationStatus = VerificationStatus.FAILED
+    operator_identity: VerificationStatus = VerificationStatus.FAILED
+    file_storage: VerificationStatus = VerificationStatus.FAILED
+    gateway_support: VerificationStatus = VerificationStatus.FAILED
+    nginx_ingress: VerificationStatus = VerificationStatus.FAILED
 
-    def to_dict(self) -> Dict[str, bool]:
-        """Convert to dictionary format matching original implementation."""
+    def to_dict(self) -> Dict[str, VerificationStatus]:
+        """Convert to dictionary format for reporting."""
         return {
             VerificationComponents.OPERATOR_POD_INSTALLED: self.operator_pod_installed,
             VerificationComponents.OPERATOR_HEALTH: self.operator_health,
@@ -226,9 +238,10 @@ class VerificationResults:
 
     @property
     def overall_success(self) -> bool:
-        """Return True if all verification steps passed."""
+        """Return True if all verification steps passed or were skipped."""
         return all(
-            [
+            status in (VerificationStatus.PASSED, VerificationStatus.SKIPPED)
+            for status in [
                 self.operator_pod_installed,
                 self.operator_health,
                 self.operator_identity,
@@ -654,24 +667,24 @@ class OperatorVerifier:
                 port=OPERATOR_HEALTH_PORT,
             )
 
-    def verify_operator_health(self, operator_data: OperatorData) -> bool:
+    def verify_operator_health(self, operator_data: OperatorData) -> VerificationStatus:
         """Verify operator health using pre-fetched data."""
         if operator_data.health.is_healthy:
-            return True
+            return VerificationStatus.PASSED
         else:
             self.log.error(
                 f"Health check failed - HTTP {operator_data.health.status_code}"
             )
             if operator_data.health.response_text:
                 self.log.error(f"Response: {operator_data.health.response_text}")
-            return False
+            return VerificationStatus.FAILED
 
     def verify_operator_identity(
         self,
         operator_data: OperatorData,
         kubernetes_config: OpenAPIKubernetesConfig,
         cloud_provider: Optional[CloudProviders],
-    ) -> bool:
+    ) -> VerificationStatus:
         """Verify operator identity using pre-fetched config data."""
         # Validate kubernetes_config contents
         expected_identity = kubernetes_config.anyscale_operator_iam_identity
@@ -679,7 +692,7 @@ class OperatorVerifier:
             self.log.error(
                 "Missing 'anyscale_operator_iam_identity' in kubernetes config"
             )
-            return False
+            return VerificationStatus.FAILED
 
         # Validate config response
         if not operator_data.config.is_valid:
@@ -688,32 +701,34 @@ class OperatorVerifier:
             )
             if operator_data.config.response_text:
                 self.log.error(f"Response: {operator_data.config.response_text}")
-            return False
+            return VerificationStatus.FAILED
 
         # Extract actual identity from config
         if operator_data.config.config_data is None:
             self.log.error("Operator config data is None")
-            return False
+            return VerificationStatus.FAILED
 
         actual_identity = operator_data.config.config_data.get("iamIdentity")
         if not actual_identity:
             self.log.error("Operator config missing 'iamIdentity' field")
-            return False
+            return VerificationStatus.FAILED
 
         # Perform identity comparison
         if self._evaluate_identity_match(
             expected_identity, actual_identity, cloud_provider
         ):
+            # Get cloud provider string for display
+            provider_str = str(cloud_provider) if cloud_provider else "AWS"
             self.log.info(
-                f"AWS identity match: Role matches (Expected: {expected_identity})"
+                f"{provider_str} identity match: Expected identity matches (Expected: {expected_identity})"
             )
-            self.log.info("Expected IAM role matches actual assumed role")
-            return True
+            self.log.info("Expected identity matches actual identity")
+            return VerificationStatus.PASSED
         else:
             self.log.error("Operator identity mismatch")
             self.log.error(f"Expected: {expected_identity}")
             self.log.error(f"Actual: {actual_identity}")
-            return False
+            return VerificationStatus.FAILED
 
     @contextmanager
     def _port_forward_to_operator(self, pod_name: str):
@@ -980,8 +995,12 @@ class StorageVerifier:
 
     def verify_file_storage(
         self, file_storage: FileStorage, cloud_deployment: CloudDeployment
-    ) -> bool:
-        """Verify file storage configuration (non-functional checks only)."""
+    ) -> VerificationStatus:
+        """Verify file storage configuration (non-functional checks only).
+
+        Returns:
+            VerificationStatus enum value
+        """
         self.log.info("Verifying file storage configuration...")
         verification_results = []
 
@@ -1014,12 +1033,15 @@ class StorageVerifier:
                     f"Cloud provider API error while verifying file storage: {e}"
                 ) from e
 
-        # Return overall success
+        # Return overall status
         if verification_results:
-            return all(result for _, result in verification_results)
+            if all(result for _, result in verification_results):
+                return VerificationStatus.PASSED
+            else:
+                return VerificationStatus.FAILED
         else:
-            self.log.info("INFO: No file storage components found to verify")
-            return True
+            self.log.info("No file storage components found to verify")
+            return VerificationStatus.SKIPPED
 
     def _verify_csi_driver(self, driver_name: str) -> bool:
         """Check if CSI driver exists on cluster."""
@@ -1135,13 +1157,17 @@ class GatewayVerifier:
         self.config = k8s_config
         self.log = logger
 
-    def verify_gateway_support(self, operator_data: OperatorData) -> bool:
-        """Verify gateway support using pre-fetched config data."""
+    def verify_gateway_support(self, operator_data: OperatorData) -> VerificationStatus:
+        """Verify gateway support using pre-fetched config data.
+
+        Returns:
+            VerificationStatus enum value
+        """
         if not operator_data.config.is_valid:
-            self.log.warning(
+            self.log.info(
                 "Could not retrieve operator configuration - skipping gateway verification"
             )
-            return True
+            return VerificationStatus.SKIPPED
 
         # Extract gateway configuration from operator data
         gateway_config = GatewayConfig.from_operator_config(
@@ -1152,21 +1178,24 @@ class GatewayVerifier:
             self.log.info(
                 "Gateway support is not enabled - skipping gateway verification"
             )
-            return True
+            return VerificationStatus.SKIPPED
 
         if not gateway_config.requires_verification:
             self.log.error(
                 "Gateway is enabled but no gateway name found in operator configuration"
             )
-            return False
+            return VerificationStatus.FAILED
 
         # Verify gateway exists in cluster
         assert (
             gateway_config.name is not None
         )  # guaranteed by requires_verification check
-        return self._verify_gateway_exists(gateway_config.name)
+        if self._verify_gateway_exists(gateway_config.name):
+            return VerificationStatus.PASSED
+        else:
+            return VerificationStatus.FAILED
 
-    def verify_nginx_ingress(self) -> bool:
+    def verify_nginx_ingress(self) -> VerificationStatus:
         """Check for NGINX ingress controller (warning only)."""
         try:
             self.log.info("Checking for NGINX ingress controller...")
@@ -1182,7 +1211,7 @@ class GatewayVerifier:
                             f"PASSED: Found running NGINX ingress controller: {nginx_pod} "
                             f"(namespace: {config_dict['namespace']})"
                         )
-                        return True
+                        return VerificationStatus.PASSED
                     else:
                         pod_status = self.kubectl.get_pod_status(
                             nginx_pod, config_dict["namespace"]
@@ -1194,14 +1223,14 @@ class GatewayVerifier:
 
             # Try fallback search by name patterns
             if self._find_nginx_by_name_pattern():
-                return True
+                return VerificationStatus.PASSED
 
             # No NGINX ingress controller found
             self.log.warning("No NGINX ingress controller found")
             self.log.warning("This may impact ingress routing capabilities")
             self.log.warning("Available ingress controllers:")
             self._list_available_ingress_controllers()
-            return False
+            return VerificationStatus.FAILED
 
         except (KubectlError, ResourceNotFoundError) as e:
             self.log.warning(f"WARNING: Could not verify NGINX ingress controller: {e}")
@@ -1437,10 +1466,6 @@ class KubernetesCloudDeploymentVerifier:
             self.log.error(f"Data parsing error during verification: {e}")
             return False
 
-    def _passed_or_failed_str_from_bool(self, is_passing: bool) -> str:
-        """Return PASSED or FAILED string for verification results, matching VM verification format."""
-        return PASSED_STATUS if is_passing else FAILED_STATUS
-
     @contextmanager
     def _verification_step(self, step_name: str):
         """Context manager for verification steps that indents detailed output."""
@@ -1467,7 +1492,7 @@ class KubernetesCloudDeploymentVerifier:
         with self._verification_step("Finding operator pod"):
             try:
                 operator_pod = operator_verifier.find_operator_pod()
-                self.results.operator_pod_installed = True
+                self.results.operator_pod_installed = VerificationStatus.PASSED
             except OperatorPodNotFoundError as e:
                 self.log.error(
                     "Failed to find operator pod, please make sure the operator is running"
@@ -1490,56 +1515,47 @@ class KubernetesCloudDeploymentVerifier:
             self.results.operator_health = operator_verifier.verify_operator_health(
                 operator_data
             )
-            self.log.info(
-                f"Operator Health: {self._passed_or_failed_str_from_bool(self.results.operator_health)}"
-            )
+            self.log.info(f"Operator Health: {self.results.operator_health.value}")
 
             self.log.info("Verifying operator identity...")
             if cloud_deployment.kubernetes_config is None:
                 self.log.error(
                     "Kubernetes configuration is missing from cloud deployment"
                 )
-                self.results.operator_identity = False
+                self.results.operator_identity = VerificationStatus.FAILED
             else:
                 self.results.operator_identity = operator_verifier.verify_operator_identity(
                     operator_data,
                     cloud_deployment.kubernetes_config,
                     cloud_deployment.provider,
                 )
-            self.log.info(
-                f"Operator Identity: {self._passed_or_failed_str_from_bool(self.results.operator_identity)}"
-            )
+            self.log.info(f"Operator Identity: {self.results.operator_identity.value}")
 
         # Step 4: Check file storage
         with self._verification_step("Checking file storage"):
             if cloud_deployment.file_storage is None:
                 self.log.info(
-                    "INFO: No file storage configured - skipping file storage verification"
+                    "No file storage configured - skipping file storage verification"
                 )
-                self.results.file_storage = True
+                self.results.file_storage = VerificationStatus.SKIPPED
             else:
                 self.results.file_storage = storage_verifier.verify_file_storage(
                     cloud_deployment.file_storage, cloud_deployment
                 )
-            self.log.info(
-                f"File Storage: {self._passed_or_failed_str_from_bool(self.results.file_storage)}"
-            )
+
+            self.log.info(f"File Storage: {self.results.file_storage.value}")
 
         # Step 5: Verify gateway support
-        with self._verification_step("Verifying gateway support"):
+        with self._verification_step("Checking gateway support"):
             self.results.gateway_support = gateway_verifier.verify_gateway_support(
                 operator_data
             )
-            self.log.info(
-                f"Gateway Support: {self._passed_or_failed_str_from_bool(self.results.gateway_support)}"
-            )
+            self.log.info(f"Gateway Support: {self.results.gateway_support.value}")
 
         # Step 6: Check NGINX ingress (warning only)
         with self._verification_step("Checking NGINX ingress controller"):
             self.results.nginx_ingress = gateway_verifier.verify_nginx_ingress()
-            self.log.info(
-                f"NGINX Ingress: {self._passed_or_failed_str_from_bool(self.results.nginx_ingress)}"
-            )
+            self.log.info(f"NGINX Ingress: {self.results.nginx_ingress.value}")
 
         self._show_verification_summary()
 
@@ -1557,9 +1573,7 @@ class KubernetesCloudDeploymentVerifier:
         verification_result_summary = ["Verification result:"]
 
         for component, result in self.results.to_dict().items():
-            verification_result_summary.append(
-                f"{component}: {self._passed_or_failed_str_from_bool(result)}"
-            )
+            verification_result_summary.append(f"{component}: {result.value}")
 
         self.log.info("\n".join(verification_result_summary))
 

anyscale/job/_private/job_sdk.py

@@ -438,7 +438,35 @@ class PrivateJobSDK(WorkloadSDK):
         self.logger.info(f"Job {job_model.id} is successfully archived.")
         return job_model.id
 
-    def wait(
+    def _stream_logs_for_job_run(
+        self, job_run_id: str, next_page_token: Optional[str] = None,
+    ) -> Optional[str]:
+        """Stream logs for a job run and return updated pagination state.
+
+        Args:
+            job_run_id: The ID of the job run to stream logs for
+            next_page_token: Token for fetching next page of logs
+
+        Returns:
+            next_page_token for the next iteration
+        """
+        try:
+            logs, next_page_token = self.client.stream_logs_for_job_run(
+                job_run_id=job_run_id, next_page_token=next_page_token,
+            )
+
+            # Print logs line by line
+            for line in logs.splitlines():
+                if line:  # Skip empty lines
+                    print(line)
+
+        except Exception as e:  # noqa: BLE001
+            # Don't fail if log streaming fails
+            self.logger.warning(f"Error streaming logs: {e}")
+
+        return next_page_token
+
+    def wait(  # noqa: PLR0912
         self,
         *,
         name: Optional[str] = None,
@@ -448,6 +476,7 @@ class PrivateJobSDK(WorkloadSDK):
         state: Union[str, JobState] = JobState.SUCCEEDED,
         timeout_s: float = 1800,
         interval_s: float = _POLLING_INTERVAL_SECONDS,
+        follow: bool = False,
     ):
         if not isinstance(timeout_s, (int, float)):
             raise TypeError("timeout_s must be a float")
@@ -471,6 +500,11 @@ class PrivateJobSDK(WorkloadSDK):
         self.logger.info(
             f"Waiting for job '{job_id_or_name}' to reach target state {state}, currently in state: {curr_state}"
         )
+
+        next_page_token = None
+        job_run_id = None
+        logs_started = False
+
         for _ in self.timer.poll(timeout_s=timeout_s, interval_s=interval_s):
             job_model = self._resolve_to_job_model(
                 name=name, job_id=job_id, cloud=cloud, project=project
@@ -483,6 +517,18 @@ class PrivateJobSDK(WorkloadSDK):
                 )
                 curr_state = new_state
 
+            # Stream logs if enabled and job has a job run
+            if follow and job_model.last_job_run_id:
+                if not logs_started:
+                    job_run_id = job_model.last_job_run_id
+                    self.logger.info(f"Starting log stream for job run {job_run_id}")
+                    logs_started = True
+
+                if job_run_id:
+                    next_page_token = self._stream_logs_for_job_run(
+                        job_run_id=job_run_id, next_page_token=next_page_token,
+                    )
+
             if curr_state == state:
                 self.logger.info(
                     f"Job '{job_id_or_name}' reached target state, exiting"

anyscale/job/commands.py

@@ -187,6 +187,7 @@ _WAIT_ARG_DOCSTRINGS = {
     "project": "Named project to use for the job. If not provided, the default project for the cloud will be used (or, if running in a workspace, the project of the workspace).",
     "state": "Target state of the job",
     "timeout_s": "Number of seconds to wait before timing out, this timeout will not affect job execution",
+    "follow": "Whether to follow the logs of the job. If True, the logs will be streamed to the console.",
 }
 
 
@@ -204,6 +205,7 @@ def wait(
     project: Optional[str] = None,
     state: Union[JobState, str] = JobState.SUCCEEDED,
     timeout_s: float = 1800,
+    follow: bool = False,
     _private_sdk: Optional[PrivateJobSDK] = None,
     **_kwargs: Dict[str, Any],
 ):
@@ -216,6 +218,7 @@ def wait(
         project=project,
         state=state,
         timeout_s=timeout_s,
+        follow=follow,
     )
 
 

anyscale/sdk/anyscale_client/models/apply_production_service_v2_model.py

@@ -47,7 +47,8 @@ class ApplyProductionServiceV2Model(object):
         'tracing_config': 'TracingConfig',
         'auto_complete_rollout': 'bool',
         'max_surge_percent': 'int',
-        'tags': 'dict(str, str)'
+        'tags': 'dict(str, str)',
+        'traffic_percent': 'int'
     }
 
     attribute_map = {
@@ -65,10 +66,11 @@ class ApplyProductionServiceV2Model(object):
         'tracing_config': 'tracing_config',
         'auto_complete_rollout': 'auto_complete_rollout',
         'max_surge_percent': 'max_surge_percent',
-        'tags': 'tags'
+        'tags': 'tags',
+        'traffic_percent': 'traffic_percent'
     }
 
-    def __init__(self, name=None, description=None, project_id=None, version=None, canary_percent=None, ray_serve_config=None, build_id=None, compute_config_id=None, config=None, rollout_strategy=None, ray_gcs_external_storage_config=None, tracing_config=None, auto_complete_rollout=True, max_surge_percent=None, tags=None, local_vars_configuration=None):  # noqa: E501
+    def __init__(self, name=None, description=None, project_id=None, version=None, canary_percent=None, ray_serve_config=None, build_id=None, compute_config_id=None, config=None, rollout_strategy=None, ray_gcs_external_storage_config=None, tracing_config=None, auto_complete_rollout=True, max_surge_percent=None, tags=None, traffic_percent=None, local_vars_configuration=None):  # noqa: E501
         """ApplyProductionServiceV2Model - a model defined in OpenAPI"""  # noqa: E501
         if local_vars_configuration is None:
             local_vars_configuration = Configuration()
@@ -89,6 +91,7 @@ class ApplyProductionServiceV2Model(object):
         self._auto_complete_rollout = None
         self._max_surge_percent = None
         self._tags = None
+        self._traffic_percent = None
         self.discriminator = None
 
         self.name = name
@@ -117,6 +120,8 @@ class ApplyProductionServiceV2Model(object):
             self.max_surge_percent = max_surge_percent
         if tags is not None:
             self.tags = tags
+        if traffic_percent is not None:
+            self.traffic_percent = traffic_percent
 
     @property
     def name(self):
@@ -471,6 +476,29 @@ class ApplyProductionServiceV2Model(object):
 
         self._tags = tags
 
+    @property
+    def traffic_percent(self):
+        """Gets the traffic_percent of this ApplyProductionServiceV2Model.  # noqa: E501
+
+         Percentage of traffic forwarded to a particular service version from the ALB.  # noqa: E501
+
+        :return: The traffic_percent of this ApplyProductionServiceV2Model.  # noqa: E501
+        :rtype: int
+        """
+        return self._traffic_percent
+
+    @traffic_percent.setter
+    def traffic_percent(self, traffic_percent):
+        """Sets the traffic_percent of this ApplyProductionServiceV2Model.
+
+         Percentage of traffic forwarded to a particular service version from the ALB.  # noqa: E501
+
+        :param traffic_percent: The traffic_percent of this ApplyProductionServiceV2Model.  # noqa: E501
+        :type: int
+        """
+
+        self._traffic_percent = traffic_percent
+
     def to_dict(self):
         """Returns the model properties as a dict"""
         result = {}

anyscale/sdk/anyscale_client/models/apply_service_model.py

@@ -47,7 +47,8 @@ class ApplyServiceModel(object):
         'tracing_config': 'TracingConfig',
         'auto_complete_rollout': 'bool',
         'max_surge_percent': 'int',
-        'tags': 'dict(str, str)'
+        'tags': 'dict(str, str)',
+        'traffic_percent': 'int'
     }
 
     attribute_map = {
@@ -65,10 +66,11 @@ class ApplyServiceModel(object):
         'tracing_config': 'tracing_config',
         'auto_complete_rollout': 'auto_complete_rollout',
         'max_surge_percent': 'max_surge_percent',
-        'tags': 'tags'
+        'tags': 'tags',
+        'traffic_percent': 'traffic_percent'
     }
 
-    def __init__(self, name=None, description=None, project_id=None, version=None, canary_percent=None, ray_serve_config=None, build_id=None, compute_config_id=None, config=None, rollout_strategy=None, ray_gcs_external_storage_config=None, tracing_config=None, auto_complete_rollout=True, max_surge_percent=None, tags=None, local_vars_configuration=None):  # noqa: E501
+    def __init__(self, name=None, description=None, project_id=None, version=None, canary_percent=None, ray_serve_config=None, build_id=None, compute_config_id=None, config=None, rollout_strategy=None, ray_gcs_external_storage_config=None, tracing_config=None, auto_complete_rollout=True, max_surge_percent=None, tags=None, traffic_percent=None, local_vars_configuration=None):  # noqa: E501
         """ApplyServiceModel - a model defined in OpenAPI"""  # noqa: E501
         if local_vars_configuration is None:
             local_vars_configuration = Configuration()
@@ -89,6 +91,7 @@ class ApplyServiceModel(object):
         self._auto_complete_rollout = None
         self._max_surge_percent = None
         self._tags = None
+        self._traffic_percent = None
         self.discriminator = None
 
         self.name = name
@@ -117,6 +120,8 @@ class ApplyServiceModel(object):
             self.max_surge_percent = max_surge_percent
         if tags is not None:
             self.tags = tags
+        if traffic_percent is not None:
+            self.traffic_percent = traffic_percent
 
     @property
     def name(self):
@@ -471,6 +476,29 @@ class ApplyServiceModel(object):
 
         self._tags = tags
 
+    @property
+    def traffic_percent(self):
+        """Gets the traffic_percent of this ApplyServiceModel.  # noqa: E501
+
+         Percentage of traffic forwarded to a particular service version from the ALB.  # noqa: E501
+
+        :return: The traffic_percent of this ApplyServiceModel.  # noqa: E501
+        :rtype: int
+        """
+        return self._traffic_percent
+
+    @traffic_percent.setter
+    def traffic_percent(self, traffic_percent):
+        """Sets the traffic_percent of this ApplyServiceModel.
+
+         Percentage of traffic forwarded to a particular service version from the ALB.  # noqa: E501
+
+        :param traffic_percent: The traffic_percent of this ApplyServiceModel.  # noqa: E501
+        :type: int
+        """
+
+        self._traffic_percent = traffic_percent
+
     def to_dict(self):
         """Returns the model properties as a dict"""
         result = {}